fix(clippy): remaining bgz17 + bgz-tensor + holograph + planner violations (manual)

53 files from agent batch runs:
- bgz17: clam_bridge, router, palette_matrix, palette_csr, simd, similarity
- bgz-tensor: attention, gamma_phi, hhtl_d/f32, matryoshka, neuron_hetero,
  palette, projection, shared_palette, similarity, slot_l, stacked,
  turboquant_kv, variance, xor_adaptive
- holograph: crystal_dejavu, dn_sparse, graphblas/*, hamming, hdr_cascade,
  mindmap, navigator, neural_tree, query/*, rl_ops, slot_encoding, storage,
  width_16k/search, width_32k/search
- lance-graph-planner: api, cache/*, compose, execute, optimize, physical/*,
  plan/*, prediction/*, strategy/*, thinking, traits

All manual. No clippy --fix. Unused imports preserved with #[allow].

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

crates/bgz-tensor/src/attention.rs

@@ -152,9 +152,9 @@ impl AttentionTable {
         let n_k = k_indices.len();
         let mut sparse = Vec::new();
 
-        for i in 0..n_q {
-            for j in 0..n_k {
-                let d = self.distance(q_indices[i], k_indices[j]);
+        for (i, &qi) in q_indices.iter().enumerate().take(n_q) {
+            for (j, &kj) in k_indices.iter().enumerate().take(n_k) {
+                let d = self.distance(qi, kj);
                 if d < threshold {
                     sparse.push((i, j, d));
                 }

crates/bgz-tensor/src/gamma_phi.rs

@@ -235,7 +235,7 @@ pub fn roundtrip_error(row: &[f32], role_gamma: f32, phi_scale: f32) -> (f64, f6
     let decoded = decode_row(&encoded, role_gamma, phi_scale);
     let mut total_err = 0.0f64;
     let mut max_err = 0.0f64;
-    for (_i, (&orig, &dec)) in row.iter().zip(decoded.iter()).enumerate() {
+    for (&orig, &dec) in row.iter().zip(decoded.iter()) {
         let err = (orig as f64 - dec as f64).abs();
         total_err += err;
         if err > max_err { max_err = err; }

crates/bgz-tensor/src/hhtl_d.rs

@@ -233,7 +233,7 @@ impl HhtlDTensor {
             let k = cache.palette.entries.len();
             let mut reps: Vec<Vec<f32>> = vec![Vec::new(); k];
             let mut rep_dists: Vec<u32> = vec![u32::MAX; k];
-            for (_i, row) in rows_f32.iter().enumerate() {
+            for row in rows_f32.iter() {
                 let b17 = Base17::from_f32(row);
                 let (ci, dist) = cache.nearest(&b17);
                 let ci = ci as usize;
@@ -243,9 +243,9 @@ impl HhtlDTensor {
                 }
             }
             // Fill empty centroids with palette to_f32
-            for ci in 0..k {
-                if reps[ci].is_empty() {
-                    reps[ci] = cache.palette.entries[ci].to_f32(n_cols);
+            for (ci, rep) in reps.iter_mut().enumerate().take(k) {
+                if rep.is_empty() {
+                    *rep = cache.palette.entries[ci].to_f32(n_cols);
                 }
             }
             Some(crate::fisher_z::FisherZTable::build(&reps, k))

crates/bgz-tensor/src/hhtl_f32.rs

@@ -93,21 +93,21 @@ fn clam_furthest_point_f32(rows: &[Vec<f32>], k: usize) -> Vec<usize> {
 
     let mut selected = vec![first];
     let mut min_dist = vec![f32::MAX; n];
-    for i in 0..n { min_dist[i] = l2_dist_sq(&rows[i], &rows[first]); }
+    for (i, md) in min_dist.iter_mut().enumerate().take(n) { *md = l2_dist_sq(&rows[i], &rows[first]); }
     min_dist[first] = 0.0;
 
     for _ in 1..k {
         let mut next = 0usize;
         let mut best = f32::MIN;
-        for i in 0..n {
-            if min_dist[i] > best { best = min_dist[i]; next = i; }
+        for (i, &md) in min_dist.iter().enumerate().take(n) {
+            if md > best { best = md; next = i; }
         }
         if best <= 0.0 { break; }  // All rows already covered
         selected.push(next);
         let cidx = next;
-        for i in 0..n {
+        for (i, md) in min_dist.iter_mut().enumerate().take(n) {
             let d = l2_dist_sq(&rows[i], &rows[cidx]);
-            if d < min_dist[i] { min_dist[i] = d; }
+            if d < *md { *md = d; }
         }
     }
     selected
@@ -203,7 +203,7 @@ impl HhtlF32Tensor {
         let centroid = &self.palette_f32[twig];
         // Cap the centroid to n_cols (may differ from original training shape).
         let mut base = vec![0.0f32; n_cols];
-        for i in 0..n_cols.min(centroid.len()) { base[i] = centroid[i]; }
+        base[..n_cols.min(centroid.len())].copy_from_slice(&centroid[..n_cols.min(centroid.len())]);
 
         match (&self.slot_l, &self.svd_basis, self.slot_l_scale) {
             (Some(sl), Some(basis), Some(scale)) if idx < sl.len() => {

crates/bgz-tensor/src/matryoshka.rs

@@ -206,8 +206,8 @@ impl SvdBasis {
         for i in 0..self.n_components {
             let start = i * self.original_cols;
             let mut dot = 0.0f64;
-            for j in 0..self.original_cols.min(row.len()) {
-                dot += row[j] as f64 * bf16_to_f32(self.basis_bf16[start + j]) as f64;
+            for (j, &rv) in row.iter().enumerate().take(self.original_cols.min(row.len())) {
+                dot += rv as f64 * bf16_to_f32(self.basis_bf16[start + j]) as f64;
             }
             coeffs.push(dot as f32);
         }
@@ -217,11 +217,10 @@ impl SvdBasis {
     /// Reconstruct a row from coefficients: coefficients[n_components] → row[cols].
     pub fn reconstruct(&self, coeffs: &[f32]) -> Vec<f32> {
         let mut row = vec![0.0f32; self.original_cols];
-        for i in 0..self.n_components.min(coeffs.len()) {
+        for (i, &c) in coeffs.iter().enumerate().take(self.n_components.min(coeffs.len())) {
             let start = i * self.original_cols;
-            let c = coeffs[i];
-            for j in 0..self.original_cols {
-                row[j] += c * bf16_to_f32(self.basis_bf16[start + j]);
+            for (j, rv) in row.iter_mut().enumerate() {
+                *rv += c * bf16_to_f32(self.basis_bf16[start + j]);
             }
         }
         row
@@ -261,10 +260,10 @@ impl SvdBasis {
         for comp in 0..d {
             // Initialize v randomly (deterministic seed)
             let mut v = vec![0.0f64; cols];
-            for j in 0..cols {
+            for (j, vj) in v.iter_mut().enumerate() {
                 // Simple hash-based initialization
                 let seed = (comp * 7919 + j * 104729 + 31) as f64;
-                v[j] = (seed.sin() * 43758.5453).fract() - 0.5;
+                *vj = (seed.sin() * 43758.5453).fract() - 0.5;
             }
             normalize_f64(&mut v);
 
@@ -303,8 +302,8 @@ impl SvdBasis {
             }
 
             // Store basis vector
-            for j in 0..cols {
-                basis_f32.push(v[j] as f32);
+            for &vj in v.iter() {
+                basis_f32.push(vj as f32);
             }
 
             // Deflate: remove this component from the matrix

crates/bgz-tensor/src/neuron_hetero.rs

@@ -447,6 +447,7 @@ impl HeterogeneousNeuronPrint {
 /// Gate becomes ThinkingStyleFingerprint.
 /// Up×Down becomes TransformSpectrum.
 /// Q, K, V become SpatialRole (StackedN + placeholder codebook index).
+#[allow(clippy::too_many_arguments)]
 pub fn build_neuron(
     layer: u16,
     feature: u32,

crates/bgz-tensor/src/palette.rs

@@ -264,13 +264,13 @@ fn compute_centroid(rows: &[Base17]) -> Base17 {
     }
     let mut sums = [0i64; 17];
     for row in rows {
-        for d in 0..17 {
-            sums[d] += row.dims[d] as i64;
+        for (d, sum) in sums.iter_mut().enumerate() {
+            *sum += row.dims[d] as i64;
         }
     }
     let mut dims = [0i16; 17];
-    for d in 0..17 {
-        dims[d] = (sums[d] / n).clamp(-32768, 32767) as i16;
+    for (d, dim) in dims.iter_mut().enumerate() {
+        *dim = (sums[d] / n).clamp(-32768, 32767) as i16;
     }
     Base17 { dims }
 }

crates/bgz-tensor/src/projection.rs

@@ -65,10 +65,10 @@ impl Base17 {
         }
 
         let mut dims = [0i16; BASE_DIM];
-        for d in 0..BASE_DIM {
+        for (d, dim) in dims.iter_mut().enumerate() {
             if count[d] > 0 {
                 let mean = sum[d] / count[d] as f64;
-                dims[d] = (mean * FP_SCALE).round().clamp(-32768.0, 32767.0) as i16;
+                *dim = (mean * FP_SCALE).round().clamp(-32768.0, 32767.0) as i16;
             }
         }
         Base17 { dims }
@@ -259,10 +259,10 @@ impl Base17Fz {
         let norm = if max_abs > 1e-15 { 1.0 / max_abs } else { 0.0 };
 
         let mut dims = [0i16; BASE_DIM];
-        for d in 0..BASE_DIM {
+        for (d, dim) in dims.iter_mut().enumerate() {
             let normalized = means[d] * norm; // [-1, 1]
             let z = arctanh_clamp(normalized);
-            dims[d] = (z * FZ_SCALE).round().clamp(-32768.0, 32767.0) as i16;
+            *dim = (z * FZ_SCALE).round().clamp(-32768.0, 32767.0) as i16;
         }
         Base17Fz { dims }
     }

crates/bgz-tensor/src/shared_palette.rs

@@ -160,7 +160,7 @@ pub fn build_shared_palette(
     }
 
     // Build from combined sample
-    let owned: Vec<Base17> = combined.iter().map(|&&ref b| b.clone()).collect();
+    let owned: Vec<Base17> = combined.iter().map(|&b| b.clone()).collect();
     let sample = if owned.len() > 4096 { &owned[..4096] } else { &owned[..] };
     WeightPalette::build(sample, k)
 }
@@ -236,9 +236,9 @@ pub fn build_group_with_fisher_z(
             rep_dists[ci] = dist;
         }
     }
-    for ci in 0..n_centroids {
-        if reps[ci].is_empty() {
-            reps[ci] = palette.entries[ci].to_f32(key.shape.1);
+    for (ci, rep) in reps.iter_mut().enumerate().take(n_centroids) {
+        if rep.is_empty() {
+            *rep = palette.entries[ci].to_f32(key.shape.1);
         }
     }
 
@@ -314,9 +314,9 @@ pub fn build_group_with_leaf(
             rep_dists[ci] = dist;
         }
     }
-    for ci in 0..n_centroids {
-        if reps[ci].is_empty() {
-            reps[ci] = palette.entries[ci].to_f32(key.shape.1);
+    for (ci, rep) in reps.iter_mut().enumerate().take(n_centroids) {
+        if rep.is_empty() {
+            *rep = palette.entries[ci].to_f32(key.shape.1);
         }
     }
     let fisher_z = Some(FisherZTable::build(&reps, n_centroids));

crates/bgz-tensor/src/similarity.rs

@@ -63,11 +63,11 @@ impl SimilarityTable {
         }
 
         // Mean cosine per bin
-        for i in 0..N_BINS {
+        for (i, bin) in bins.iter_mut().enumerate().take(N_BINS) {
             if bin_counts[i] > 0 {
-                bins[i] = (bin_sums[i] / bin_counts[i] as f64) as f32;
+                *bin = (bin_sums[i] / bin_counts[i] as f64) as f32;
             } else {
-                bins[i] = f32::NAN; // will be interpolated
+                *bin = f32::NAN; // will be interpolated
             }
         }
 
@@ -84,8 +84,8 @@ impl SimilarityTable {
     /// similarity = 1.0 - l1/max_l1.
     pub fn linear_fallback(max_l1: u32) -> Self {
         let mut bins = [0.0f32; N_BINS];
-        for i in 0..N_BINS {
-            bins[i] = 1.0 - (i as f32 / 255.0);
+        for (i, bin) in bins.iter_mut().enumerate().take(N_BINS) {
+            *bin = 1.0 - (i as f32 / 255.0);
         }
         SimilarityTable { max_l1, bins }
     }
@@ -102,9 +102,9 @@ impl SimilarityTable {
                     if gap > 1 {
                         let start_val = bins[prev];
                         let end_val = bins[i];
-                        for j in (prev + 1)..i {
-                            let t = (j - prev) as f32 / gap as f32;
-                            bins[j] = start_val + t * (end_val - start_val);
+                        for (offset, bin) in bins[(prev + 1)..i].iter_mut().enumerate() {
+                            let t = (offset + 1) as f32 / gap as f32;
+                            *bin = start_val + t * (end_val - start_val);
                         }
                     }
                 }
@@ -125,8 +125,8 @@ impl SimilarityTable {
         }
         // If all NaN, default to linear
         if bins[0].is_nan() {
-            for i in 0..N_BINS {
-                bins[i] = 1.0 - i as f32 / 255.0;
+            for (i, bin) in bins.iter_mut().enumerate().take(N_BINS) {
+                *bin = 1.0 - i as f32 / 255.0;
             }
         }
     }