chore(clippy): adopt as_chunks, unbreaking CI on the current toolchain

CI runs 'cargo clippy --all-targets -- -D warnings' on the latest stable. A
newer clippy added chunks_exact_to_as_chunks, so master and every PR opened
against it now fail the Check job on code nobody touched. Master last went
green on 2026-08-11.

Five sites, all with a CONSTANT chunk size: sparse_reader (8 and 4),
redis_utils ft_info_num_docs / ft_info_index_memory_bytes (2), and the kividb
integration helper (2).

The sparse_reader change is a small real improvement rather than lint
appeasement: as_chunks::<N>() yields &[u8; N] directly, so the fallible
try_into().unwrap() that chunks_exact forced is gone -- the length is proven by
the type instead of re-checked at runtime.

Verified with beta clippy (0.1.98, matching what CI resolves) clean at
-D warnings, and built + unit-tested on stable 0.1.97 so this does not require
a toolchain bump.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: fcostaoliveira

src/bin/vector_db_benchmark/engine/redis_utils.rs

@@ -393,7 +393,9 @@ pub fn ft_info_num_docs(v: &redis::Value) -> Option<u64> {
     let pairs: Vec<(String, &redis::Value)> = match v {
         redis::Value::Map(m) => m.iter().map(|(k, val)| (value_to_string(k), val)).collect(),
         redis::Value::Array(items) => items
-            .chunks_exact(2)
+            .as_chunks::<2>()
+            .0
+            .iter()
             .map(|c| (value_to_string(&c[0]), &c[1]))
             .collect(),
         _ => return None,
@@ -455,7 +457,9 @@ pub fn ft_info_index_memory_bytes(v: &redis::Value) -> Option<i64> {
     let pairs: Vec<(String, &redis::Value)> = match v {
         redis::Value::Map(m) => m.iter().map(|(k, val)| (value_to_string(k), val)).collect(),
         redis::Value::Array(items) => items
-            .chunks_exact(2)
+            .as_chunks::<2>()
+            .0
+            .iter()
             .map(|c| (value_to_string(&c[0]), &c[1]))
             .collect(),
         _ => return None,

src/readers/sparse_reader.rs

@@ -40,9 +40,14 @@ fn read_i64_le(r: &mut impl Read, n: usize, max_bytes: u64) -> Result<Vec<i64>,
     }
     let mut buf = vec![0u8; byte_len];
     r.read_exact(&mut buf).map_err(|e| e.to_string())?;
+    // `as_chunks::<8>()` yields `&[u8; 8]` directly, so the fallible
+    // `try_into().unwrap()` that `chunks_exact` forced is gone: the length is
+    // now proven by the type rather than re-checked at runtime.
     Ok(buf
-        .chunks_exact(8)
-        .map(|c| i64::from_le_bytes(c.try_into().unwrap()))
+        .as_chunks::<8>()
+        .0
+        .iter()
+        .map(|c| i64::from_le_bytes(*c))
         .collect())
 }
 
@@ -66,10 +71,7 @@ fn read_u32_array<T>(
     }
     let mut buf = vec![0u8; byte_len];
     r.read_exact(&mut buf).map_err(|e| e.to_string())?;
-    Ok(buf
-        .chunks_exact(4)
-        .map(|c| f(c.try_into().unwrap()))
-        .collect())
+    Ok(buf.as_chunks::<4>().0.iter().map(|c| f(*c)).collect())
 }
 
 /// Number of rows a CSR file declares, read from its 24-byte header WITHOUT

tests/integration_kividb.rs

@@ -1226,7 +1226,12 @@ fn ft_info_field_names(v: &redis::Value) -> Vec<String> {
     }
     match v {
         redis::Value::Map(m) => m.iter().map(|(k, _)| as_str(k)).collect(),
-        redis::Value::Array(items) => items.chunks_exact(2).map(|c| as_str(&c[0])).collect(),
+        redis::Value::Array(items) => items
+            .as_chunks::<2>()
+            .0
+            .iter()
+            .map(|c| as_str(&c[0]))
+            .collect(),
         _ => Vec::new(),
     }
 }