style: rustfmt cleanup for fmt --all CI gate

Five locations across two files where my recent commits had lines
slightly over the rustfmt width:
  - simd_int_ops.rs tests: 3× iterator chain reflows (.collect()
    onto its own line)
  - simd_ops.rs:505 — `array_windows` count computation broken to
    if/else block form
  - simd_ops.rs:679 / :686 — ref_add_mul_{f32,f64} test helpers
    reflow .iter().zip(...).map(...).collect() onto multi-line

Pure whitespace / formatting; no semantic changes. 15 simd_int_ops
tests + 29 simd_ops tests still pass on default v3.

https://claude.ai/code/session_01HbqooFZHAjaUtFEzhA1R2u

Author: claude

src/simd_int_ops.rs

@@ -641,7 +641,9 @@ mod tests {
         let n = 17;
         let k = 17;
         let a: Vec<u8> = (0..m * k).map(|i| ((i * 7 + 3) % 256) as u8).collect();
-        let b: Vec<i8> = (0..k * n).map(|i| ((i * 11 + 5) % 256) as u8 as i8).collect();
+        let b: Vec<i8> = (0..k * n)
+            .map(|i| ((i * 11 + 5) % 256) as u8 as i8)
+            .collect();
         let expected = ref_gemm_u8_i8(&a, &b, m, n, k);
         let mut c = vec![0i32; m * n];
         gemm_u8_i8(&a, &b, &mut c, m, n, k);
@@ -656,7 +658,9 @@ mod tests {
         let n = 4;
         let k = 8;
         let a = vec![255u8; m * k];
-        let b: Vec<i8> = (0..k * n).map(|i| if i % 2 == 0 { 127i8 } else { -128i8 }).collect();
+        let b: Vec<i8> = (0..k * n)
+            .map(|i| if i % 2 == 0 { 127i8 } else { -128i8 })
+            .collect();
         let expected = ref_gemm_u8_i8(&a, &b, m, n, k);
         let mut c = vec![0i32; m * n];
         gemm_u8_i8(&a, &b, &mut c, m, n, k);
@@ -685,7 +689,9 @@ mod tests {
 
         for (m, n, k) in sizes {
             let a: Vec<u8> = (0..m * k).map(|i| (i % 251) as u8).collect();
-            let b: Vec<i8> = (0..k * n).map(|i| ((i % 127) as i8).wrapping_sub(63)).collect();
+            let b: Vec<i8> = (0..k * n)
+                .map(|i| ((i % 127) as i8).wrapping_sub(63))
+                .collect();
             let mut c_simd = vec![0i32; m * n];
             let mut c_scalar = vec![0i32; m * n];
 

src/simd_ops.rs

@@ -505,7 +505,11 @@ pub fn array_chunks_checked<T, const N: usize>(data: &[T]) -> Result<impl Iterat
 pub fn array_windows<T, const N: usize>(data: &[T]) -> impl Iterator<Item = &[T; N]> + '_ {
     // Index-based iteration sidesteps `slice::windows(0)`'s panic — when
     // N == 0 the count below evaluates to 0 and the iterator is empty.
-    let count = if N == 0 || data.len() < N { 0 } else { data.len() - N + 1 };
+    let count = if N == 0 || data.len() < N {
+        0
+    } else {
+        data.len() - N + 1
+    };
     (0..count).map(move |i| {
         // `&data[i..i + N]` is exactly N elements by construction (bounds
         // checked once when `count` was computed). `try_into` always
@@ -679,11 +683,19 @@ mod add_mul_tests {
     use super::*;
 
     fn ref_add_mul_f32(acc: &[f32], a: &[f32], b: &[f32]) -> Vec<f32> {
-        acc.iter().zip(a).zip(b).map(|((&c, &x), &y)| x.mul_add(y, c)).collect()
+        acc.iter()
+            .zip(a)
+            .zip(b)
+            .map(|((&c, &x), &y)| x.mul_add(y, c))
+            .collect()
     }
 
     fn ref_add_mul_f64(acc: &[f64], a: &[f64], b: &[f64]) -> Vec<f64> {
-        acc.iter().zip(a).zip(b).map(|((&c, &x), &y)| x.mul_add(y, c)).collect()
+        acc.iter()
+            .zip(a)
+            .zip(b)
+            .map(|((&c, &x), &y)| x.mul_add(y, c))
+            .collect()
     }
 
     #[test]