Optimize PrimaryKey memory: serialize CqlValue into compact byte buffer

Replace PrimaryKey(Vec<CqlValue>) with a serialized byte buffer
representation backed by a new InvariantKey type. CqlValue is 72 bytes
per element due to enum sizing, wasting significant memory for typical
primary key types like Int (4 bytes of data, 68 bytes of padding).

InvariantKey stores values as Arc<[u8]> with a 1-byte type tag followed
by the minimal binary encoding for each value:

  Int:      5 bytes  (was 72) — 14× smaller
  BigInt:   9 bytes  (was 72) — 8× smaller
  Uuid:    17 bytes  (was 72) — 4× smaller
  Text(s):  5+len    (was 72) — variable

For a single Int primary key column, total per-row memory drops from
~96 bytes (24 Vec overhead + 72 CqlValue) to ~22 bytes (16 Arc<[u8]> +
6 heap), a 4× improvement. With millions of indexed rows stored in the
BiMap, this substantially reduces RSS.

Design:
- invariant_key.rs: reusable encoding engine with InvariantKey,
  InvariantKeyBuilder, and InvariantKeyIter types.
- primary_key.rs: thin newtype providing primary-key-specific semantics.
- O(1) clone via Arc; values decoded on demand via get(index) or iter(),
  acceptable for primary keys with 1–3 columns.
- Hash/Eq operate on raw bytes instead of format!("{:?}"), which is both
  faster and avoids Debug format instability.
- hash_prefix() uses a separate hash domain from Hash::hash (documented).
- Variable-length encoding guards against u32 overflow via try_into().
- InvariantKeyIter implements ExactSizeIterator and FusedIterator.

Changes:
- Add invariant_key.rs with encode/decode, Hash, Eq, Debug, Iterator
- Add primary_key.rs as a newtype over InvariantKey
- Update usearch.rs: closures return owned CqlValue instead of refs
- Update httproutes.rs: use PrimaryKey::len()/get() API
- Remove old PrimaryKey struct and format-based Hash impl from lib.rs

Fixes: VECTOR-526

Author: swasik

crates/vector-store/src/httproutes.rs

@@ -606,16 +606,20 @@ async fn post_index_ann(
                         let primary_keys: anyhow::Result<_> = primary_keys
                             .iter()
                             .map(|primary_key| {
-                                if primary_key.0.len() != primary_key_columns.len() {
+                                if primary_key.len() != primary_key_columns.len() {
                                     bail!(
                                         "wrong size of a primary key: {}, {}",
                                         primary_key_columns.len(),
-                                        primary_key.0.len()
+                                        primary_key.len()
                                     );
                                 }
                                 Ok(primary_key)
                             })
-                            .map_ok(|primary_key| primary_key.0[idx_column].clone())
+                            .map_ok(|primary_key| {
+                                primary_key
+                                    .get(idx_column)
+                                    .expect("primary key index out of bounds after length check")
+                            })
                             .map_ok(try_to_json)
                             .map(|primary_key| primary_key.flatten())
                             .collect();

crates/vector-store/src/index/usearch.rs

@@ -897,15 +897,15 @@ fn cql_cmp(lhs: &CqlValue, rhs: &CqlValue) -> Option<std::cmp::Ordering> {
 
 /// Lexicographically compare tuple values.
 /// Returns the ordering of the first non-equal pair, or Equal if all pairs are equal.
-fn cql_cmp_tuple<'a>(
-    primary_key: &'a PrimaryKey,
-    primary_key_value: impl Fn(&'a PrimaryKey, &ColumnName) -> Option<&'a CqlValue>,
+fn cql_cmp_tuple(
+    primary_key: &PrimaryKey,
+    primary_key_value: impl Fn(&PrimaryKey, &ColumnName) -> Option<CqlValue>,
     lhs: &[ColumnName],
     rhs: &[CqlValue],
 ) -> Option<std::cmp::Ordering> {
     for (col, rhs_val) in lhs.iter().zip(rhs.iter()) {
         let lhs_val = primary_key_value(primary_key, col)?;
-        match cql_cmp(lhs_val, rhs_val)? {
+        match cql_cmp(&lhs_val, rhs_val)? {
             std::cmp::Ordering::Equal => continue,
             other => return Some(other),
         }
@@ -924,17 +924,17 @@ fn filtered_ann(
 ) {
     fn annotate<F>(f: F) -> F
     where
-        F: for<'a, 'b> Fn(&'a PrimaryKey, &'b ColumnName) -> Option<&'a CqlValue>,
+        F: Fn(&PrimaryKey, &ColumnName) -> Option<CqlValue>,
     {
         f
     }
 
     let primary_key_value = annotate(
-        |primary_key: &PrimaryKey, name: &ColumnName| -> Option<&CqlValue> {
+        |primary_key: &PrimaryKey, name: &ColumnName| -> Option<CqlValue> {
             primary_key_columns
                 .iter()
                 .position(|key_column| key_column == name)
-                .and_then(move |idx| primary_key.0.get(idx))
+                .and_then(move |idx| primary_key.get(idx))
         },
     );
 
@@ -946,27 +946,29 @@ fn filtered_ann(
             .restrictions
             .iter()
             .all(|restriction| match restriction {
-                Restriction::Eq { lhs, rhs } => primary_key_value(&primary_key, lhs) == Some(rhs),
+                Restriction::Eq { lhs, rhs } => {
+                    primary_key_value(&primary_key, lhs).as_ref() == Some(rhs)
+                }
                 Restriction::In { lhs, rhs } => {
                     let value = primary_key_value(&primary_key, lhs);
-                    rhs.iter().any(|rhs| value == Some(rhs))
+                    rhs.iter().any(|rhs| value.as_ref() == Some(rhs))
                 }
                 Restriction::Lt { lhs, rhs } => primary_key_value(&primary_key, lhs)
-                    .and_then(|value| cql_cmp(value, rhs))
+                    .and_then(|value| cql_cmp(&value, rhs))
                     .is_some_and(|ord| ord.is_lt()),
                 Restriction::Lte { lhs, rhs } => primary_key_value(&primary_key, lhs)
-                    .and_then(|value| cql_cmp(value, rhs))
+                    .and_then(|value| cql_cmp(&value, rhs))
                     .is_some_and(|ord| ord.is_le()),
                 Restriction::Gt { lhs, rhs } => primary_key_value(&primary_key, lhs)
-                    .and_then(|value| cql_cmp(value, rhs))
+                    .and_then(|value| cql_cmp(&value, rhs))
                     .is_some_and(|ord| ord.is_gt()),
                 Restriction::Gte { lhs, rhs } => primary_key_value(&primary_key, lhs)
-                    .and_then(|value| cql_cmp(value, rhs))
+                    .and_then(|value| cql_cmp(&value, rhs))
                     .is_some_and(|ord| ord.is_ge()),
                 Restriction::EqTuple { lhs, rhs } => lhs
                     .iter()
                     .zip(rhs.iter())
-                    .all(|(lhs, rhs)| primary_key_value(&primary_key, lhs) == Some(rhs)),
+                    .all(|(lhs, rhs)| primary_key_value(&primary_key, lhs).as_ref() == Some(rhs)),
                 Restriction::InTuple { lhs, rhs } => {
                     let values: Vec<_> = lhs
                         .iter()
@@ -976,7 +978,7 @@ fn filtered_ann(
                         values
                             .iter()
                             .zip(rhs.iter())
-                            .all(|(value, rhs)| value == &Some(rhs))
+                            .all(|(value, rhs)| value.as_ref() == Some(rhs))
                     })
                 }
                 Restriction::LtTuple { lhs, rhs } => {
@@ -1464,14 +1466,14 @@ mod tests {
             values.into()
         }
 
-        fn primary_key_value_fn<'a>(
-            columns: &'a [ColumnName],
-        ) -> impl Fn(&'a PrimaryKey, &ColumnName) -> Option<&'a CqlValue> {
-            move |pk: &'a PrimaryKey, name: &ColumnName| {
+        fn primary_key_value_fn(
+            columns: &[ColumnName],
+        ) -> impl Fn(&PrimaryKey, &ColumnName) -> Option<CqlValue> + use<'_> {
+            move |pk: &PrimaryKey, name: &ColumnName| {
                 columns
                     .iter()
                     .position(|col| col == name)
-                    .and_then(|idx| pk.0.get(idx))
+                    .and_then(|idx| pk.get(idx))
             }
         }