fix(clippy): pay down bgz17 violations (manual, loop-index batch)

- clam_bridge.rs: 4 needless_range_loop → iter/iter_mut().enumerate()
  (seed distance sum, radius/pole finding, side partitioning)
- router.rs: identical if blocks → consolidated with ||
- palette_matrix.rs: needless_range_loop → iter().enumerate()
- palette_csr.rs: needless_range_loop → slice iterator
- simd.rs: too_many_arguments → #[allow(clippy::too_many_arguments)]
- similarity.rs: 2 needless_range_loop → iter_mut().enumerate()

Remaining 7 errors are in container.rs and rabitq_compat.rs
(already handled in prior commit scope, DO NOT TOUCH).

https://claude.ai/code/session_01SbYsmmbPf9YQuYbHZN52Zh

Author: claude

crates/bgz17/src/clam_bridge.rs

@@ -309,9 +309,9 @@ impl Bgz17ClamTree {
             for s in 0..num_seeds {
                 let si = working[s];
                 let mut sum = 0u64;
-                for t in 0..num_seeds {
+                for (t, &wt) in working.iter().enumerate().take(num_seeds) {
                     if s != t {
-                        sum += metric.distance(si, working[t]);
+                        sum += metric.distance(si, wt);
                     }
                 }
                 if sum < best_sum {
@@ -331,8 +331,8 @@ impl Bgz17ClamTree {
         let mut left_pole_dist = 0u64;
 
         let mut distances: Vec<u64> = Vec::with_capacity(n);
-        for i in 0..n {
-            let d = metric.distance(center_idx, working[i]);
+        for (i, &wi) in working.iter().enumerate() {
+            let d = metric.distance(center_idx, wi);
             distances.push(d);
             if d > radius { radius = d; }
             if d > left_pole_dist {
@@ -351,8 +351,8 @@ impl Bgz17ClamTree {
         let left_pole_idx = working[left_pole_local];
         let mut right_pole_local = 0;
         let mut right_pole_dist = 0u64;
-        for i in 0..n {
-            let d = metric.distance(left_pole_idx, working[i]);
+        for (i, &wi) in working.iter().enumerate() {
+            let d = metric.distance(left_pole_idx, wi);
             if d > right_pole_dist {
                 right_pole_dist = d;
                 right_pole_local = i;
@@ -362,9 +362,9 @@ impl Bgz17ClamTree {
 
         // Partition into L and R
         let mut side: Vec<bool> = Vec::with_capacity(n);
-        for i in 0..n {
-            let dl = metric.distance(left_pole_idx, working[i]);
-            let dr = metric.distance(right_pole_idx, working[i]);
+        for &wi in working.iter() {
+            let dl = metric.distance(left_pole_idx, wi);
+            let dr = metric.distance(right_pole_idx, wi);
             side.push(dl <= dr);
         }
 

crates/bgz17/src/palette_csr.rs

@@ -257,8 +257,7 @@ impl PaletteCsr {
 /// Returns (verb, target) pairs, stopping at first zero edge.
 fn extract_inline_edges(container: &[u64; CONTAINER_WORDS]) -> Vec<(u8, u8)> {
     let mut edges = Vec::new();
-    for w in W_INLINE_EDGES_START..=W_INLINE_EDGES_END {
-        let word = container[w];
+    for &word in &container[W_INLINE_EDGES_START..=W_INLINE_EDGES_END] {
         if word == 0 { break; }
         for shift in (0..64).step_by(16) {
             let verb = ((word >> shift) & 0xFF) as u8;

crates/bgz17/src/palette_matrix.rs

@@ -148,10 +148,10 @@ impl PaletteMatrix {
             }
 
             // Emit row entries
-            for j in 0..ncols {
-                if let Some((pe, _)) = best[j] {
+            for (j, best_j) in best.iter().enumerate().take(ncols) {
+                if let Some((pe, _)) = best_j {
                     col_idx.push(j);
-                    vals.push(pe);
+                    vals.push(*pe);
                 }
             }
             row_ptr.push(col_idx.len());

crates/bgz17/src/router.rs

@@ -137,9 +137,7 @@ impl FallbackSignals {
 
     /// Determine minimum precision needed based on signals.
     pub fn minimum_precision(&self) -> crate::Precision {
-        if self.max_anomaly_score > 0.75 {
-            crate::Precision::Base
-        } else if self.palette_collision_rate > 0.10 {
+        if self.max_anomaly_score > 0.75 || self.palette_collision_rate > 0.10 {
             crate::Precision::Base
         } else {
             crate::Precision::Palette

crates/bgz17/src/simd.rs

@@ -142,6 +142,7 @@ unsafe fn avx2_batch(dm_data: &[u16], k: usize, query: u8, candidates: &[u8], ou
 ///
 /// For each candidate i:
 ///   out[i] = dm_s[q_s][c_s[i]] + dm_p[q_p][c_p[i]] + dm_o[q_o][c_o[i]]
+#[allow(clippy::too_many_arguments)]
 pub fn batch_spo_distance(
     dm: &SpoDistanceMatrices,
     query_s: u8,

crates/bgz17/src/similarity.rs

@@ -26,10 +26,10 @@ impl SimilarityTable {
         let mut table = [0.0f32; 256];
         let sigma_f = (sigma.max(1)) as f32;
         let mu_f = mu as f32;
-        for i in 0..256 {
+        for (i, entry) in table.iter_mut().enumerate() {
             let distance = (i as u32 * bucket_width) + bucket_width / 2;
             let z = (mu_f - distance as f32) / sigma_f;
-            table[i] = 1.0 / (1.0 + (-z).exp());
+            *entry = 1.0 / (1.0 + (-z).exp());
         }
         Self { table, bucket_width, max_distance }
     }
@@ -50,12 +50,12 @@ impl SimilarityTable {
         let bucket_width = (max_distance / 256).max(1);
         let mut table = [0.0f32; 256];
 
-        for i in 0..256 {
+        for (i, entry) in table.iter_mut().enumerate() {
             let bucket_center = (i as u32 * bucket_width) + bucket_width / 2;
             // CDF: fraction of samples <= bucket_center
             let count = samples.partition_point(|&s| s <= bucket_center);
             let cdf = count as f32 / n as f32;
-            table[i] = 1.0 - cdf; // similarity = 1 - CDF
+            *entry = 1.0 - cdf; // similarity = 1 - CDF
         }
 
         Self { table, bucket_width, max_distance }