feat: slim down zvec dynamic libraries

[chinaux]

Summary

This PR substantially reduces the size of zvec's prebuilt dynamic libraries with
zero functional loss and no public API change. Core search code stays at
-O3, so query performance is unaffected.

Measured on macOS arm64, Release + strip, both built from the same base commit
(d15a37e):

Library	main baseline	this PR	Reduction
libzvec_c_api.dylib (C API)	31.11 MB	19.19 MB	-11.92 MB (-38.3%)
libzvec.dylib (C++ SDK)	30.88 MB	20.44 MB	-10.44 MB (-33.8%)

It also removes the protobuf/protoc build dependency entirely while keeping
the on-disk manifest format byte-for-byte compatible.

Motivation

Both dynamic libraries statically bundle heavy third-party dependencies (Arrow,
RocksDB, protobuf, ANTLR4, glog). By default they export all of those
symbols and carry code paths zvec never uses. That inflates binary size, slows
down linking, and pollutes the global symbol namespace for downstream consumers.

protobuf was a particularly poor trade: zvec only used it to persist the
collection manifest, yet it pulled in a code generator (protoc), a submodule,
and a runtime library into every build.

Approach

1. Symbol visibility & dead-code elimination

• Compile with -ffunction-sections -fdata-sections so unreachable code can be
  pruned at link time.
• macOS: -exported_symbols_list + -dead_strip
• Linux: --version-script + --gc-sections
• libzvec_c_api exports only the zvec_* C API.
• libzvec exports only zvec's own public C++ API (namespace zvec, including
  the nested zvec::ailego / zvec::core / zvec::turbo / zvec::reranker),
  hiding ~14.5k third-party symbols (exported symbols: 23,102 → 8,609).

The public C++ headers never expose Arrow/RocksDB/Parquet types, so hiding
those symbols is safe for external C++ consumers.

Two follow-up fixes were needed to make the Linux script correct:

• Export the mangled vtable / typeinfo / VTT / guard-variable patterns
  (_ZTVN4zvec*, _ZTIN4zvec*, ...). The demangled zvec::* glob does not
  match them, so consumers previously failed with
  undefined reference to vtable for zvec::core_interface::HNSWIndexParam.
• Drop the quoted "zvec::*" entry: in version scripts a quoted name is a
  literal match, not a glob. GNU ld silently ignores the never-matching entry,
  but lld (Android NDK) fails under --no-undefined-version.

2. Drop the protobuf / protoc dependency

The manifest is now encoded by a self-contained codec instead of generated
protobuf code:

• pb_wire.h — a minimal protobuf wire-format reader/writer (varint,
  fixed32/64, length-delimited). Unknown fields are consumed and ignored to
  preserve proto3 forward compatibility; malformed input (bad varint,
  out-of-range length, groups, field number 0) is reported rather than crashing.
• manifest_codec.{h,cc} — converts all 16 messages directly between zvec's C++
  types and bytes, with no intermediate message object.
• manifest_enum.h — the on-disk enum values, preserved exactly.

The thirdparty/protobuf submodule, src/db/proto/zvec.proto and the generated
proto_converter are removed.

Format compatibility is enforced by two test suites:

1. While libprotobuf was still in the tree (commit 9a27877), a temporary
   manifest_codec_test.cc cross-checked both implementations: every message had
   to encode to identical bytes, and each side had to parse the other's output.
   This covered the subtle cases — always-present base / quantizer_param
   sub-messages, the absent quantizer_param of HNSW_RABITQ, Vamana's
   fixed32 alpha, empty strings. That test was removed together with the
   dependency in d8cd772, since it cannot compile without libprotobuf.
2. manifest_codec_golden_test.cc (kept) pins golden byte arrays that were
   produced by the old protobuf implementation. It has no libprotobuf
   dependency, so it continues to guard on-disk format compatibility now that
   the dependency is gone.

Existing collections therefore remain readable, and manifests written by this
build remain readable by older releases.

3. Third-party feature trimming

• Arrow: ARROW_DATASET=OFF; unused Compute kernels trimmed via
  thirdparty/arrow/arrow.slim_compute.patch (aggregates, hash-aggregates,
  temporal, round, random, rank, replace, select_k, statistics,
  cumulative_ops, pivot).
• RocksDB: trace / iostats / perf contexts disabled.

Note on the Arrow patch: an earlier revision over-trimmed and broke production
paths, because several kernels are reached indirectly through Acero nodes and
are invisible to a source grep. sort_indices (needed by the order_by node
that sorts vector scores and FTS BM25 results), make_struct (the backing
implementation of compute::project()), match_like (SQL LIKE) and
list_value_length (SQL array_length()) are all restored, and each retained
kernel now carries a comment stating why it is required.

4. Size-optimized third-party builds

• GCC/Clang: -Os for RocksDB / glog / ANTLR4, MinSizeRel for Arrow.
• MSVC: /O1 /Ob1 (favor small code) instead of /O2 /Ob2, including Arrow's
  Release configuration — mirroring the -Os / MinSizeRel behavior above.

zvec's own code is untouched and keeps its default optimization level.

Where the remaining size goes

For reference, a link-map attribution of the resulting C API library:

Component	Size	Share
Arrow stack (core + compute + acero + parquet + bundled)	9.37 MB	49.6%
zvec's own code (core + db + ailego + turbo + c_api)	5.44 MB	28.8%
RocksDB	2.93 MB	15.5%
Other third-party (snowball / ANTLR4 / lz4 / glog / roaring / FastPFOR)	1.14 MB	6.0%

Compatibility

• No public API changes: headers under src/include/zvec/ keep their
  existing declarations; only symbol visibility and unused internals changed.
• On-disk format unchanged: the manifest is still protobuf wire format,
  pinned by golden-byte tests.
• Third-party sources are not modified in place: Arrow trimming is applied
  as a patch at build time, keeping submodules pristine.
• Existing C / C++ / Python examples and tests pass unchanged.

Testing

• Full C++ unit test suite, Python tests, and the C/C++ examples pass on
  macOS (arm64), Linux (x64/arm64), Windows (x64), plus Android and iOS builds.
• Manifest format verified by byte-level cross-checks against libprotobuf and by
  golden-byte tests.
• Exported symbol tables inspected with nm / objdump to confirm only the
  intended public symbols remain, and that no third-party symbols leak.
• Library sizes verified on each platform.