fix: stop the lint pass adding rustfmt debt to #12

The lint work added 8 rustfmt hunks. Run 206's Formatting job reports 782
where run 204 reported 774, and the difference is mine — debt added to the
one issue the lint pass argued should not be disturbed. Measured against a
`b6466cb` worktree under the same rustfmt, the tree is back to 774: equal
to baseline, not merely close to it.

Two causes, both interactions rather than mistakes of judgement:

`cargo clippy --fix` writes its replacement on one line. Where the call
sat inside a multi-line method chain that produced

    .as_chunks::<2>().0.iter()

which rustfmt wants split across three lines. Seven sites, in
`formats/{audio,vfs,game_data}.rs` and `cli/main.rs`. An eighth was a
`for` header pushed past the width limit; it reads better as two bindings
than as a six-line chain, so that is what it became.

The last one is subtler and was the only file left over after the other
seven were fixed. `ship_capture.rs` had

    let mut flush = |base: u32,
                     size: u32,

and clippy correctly removed the `mut`. That shortens the line by four
characters, so the closure's six continuation parameters were then
aligned four columns too far right — a formatting change caused by a
change on a different line, in a file whose own hunk count is what
exposed it.

Worth recording because it generalises: `--fix` output is not rustfmt
output, and on a tree that is not rustfmt-clean the difference is
invisible in the diff and only shows up as a hunk count moving. The check
that catches it is a count against a same-toolchain baseline, not an
inspection of the patch.

Re-verified after the reformat, since these edits changed real lines:

    cargo clippy --workspace -- -D warnings   exit 0
    cargo test   --workspace                  exit 0   207 passed, 0 failed
    cargo fmt    --all -- --check             774 hunks == baseline

Refs #12, #13

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01McNbzUeq1KRBWs4G6X2YVj

crates/sylpheed-cli/src/main.rs

@@ -1060,7 +1060,9 @@ fn cmd_mesh_info(file: &Path) -> Result<()> {
             };
             let mut maxedges: Vec<f32> = sub
                 .indices
-                .as_chunks::<3>().0.iter()
+                .as_chunks::<3>()
+                .0
+                .iter()
                 .map(|t| edge(t[0], t[1]).max(edge(t[1], t[2])).max(edge(t[0], t[2])))
                 .collect();
             maxedges.sort_by(|a, b| a.partial_cmp(b).unwrap());
@@ -1224,7 +1226,9 @@ fn cmd_mesh_render(
             let med = {
                 let mut e: Vec<f32> = sub
                     .indices
-                    .as_chunks::<3>().0.iter()
+                    .as_chunks::<3>()
+                    .0
+                    .iter()
                     .filter(|t| (t[0] as usize) < n && (t[1] as usize) < n && (t[2] as usize) < n)
                     .map(|t| {
                         let d = |a: u32, b: u32| {
@@ -1444,7 +1448,9 @@ fn decode_to_rgba8(tex: &sylpheed_formats::texture::X360Texture) -> Result<Vec<u
             // [A,R,G,B] byte order (verified against the retail Acheron backdrop).
             // Emit RGBA. X8 has no meaningful alpha.
             let opaque = matches!(tex.format, F::X8R8G8B8);
-            for (px, out) in tex.data.as_chunks::<4>().0.iter().zip(rgba.as_chunks_mut::<4>().0) {
+            let src = tex.data.as_chunks::<4>().0;
+            let dst = rgba.as_chunks_mut::<4>().0;
+            for (px, out) in src.iter().zip(dst) {
                 out[0] = px[1]; // R
                 out[1] = px[2]; // G
                 out[2] = px[3]; // B

crates/sylpheed-formats/src/audio.rs

@@ -276,11 +276,15 @@ impl GameAudio {
         let samples: Vec<f32> = match (info.codec, bits) {
             (AudioCodec::Pcm, 8) => data.iter().map(|&b| (b as f32 - 128.0) / 128.0).collect(),
             (AudioCodec::Pcm, 16) => data
-                .as_chunks::<2>().0.iter()
+                .as_chunks::<2>()
+                .0
+                .iter()
                 .map(|c| i16::from_le_bytes([c[0], c[1]]) as f32 / 32768.0)
                 .collect(),
             (AudioCodec::Pcm, 24) => data
-                .as_chunks::<3>().0.iter()
+                .as_chunks::<3>()
+                .0
+                .iter()
                 .map(|c| {
                     let v = ((c[2] as i32) << 16) | ((c[1] as i32) << 8) | c[0] as i32;
                     let v = (v << 8) >> 8; // sign-extend 24→32
@@ -288,7 +292,9 @@ impl GameAudio {
                 })
                 .collect(),
             (AudioCodec::PcmFloat, 32) => data
-                .as_chunks::<4>().0.iter()
+                .as_chunks::<4>()
+                .0
+                .iter()
                 .map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
                 .collect(),
             _ => return Err(AudioError::UnsupportedPcm { tag: 0, bits }),

crates/sylpheed-formats/src/game_data.rs

@@ -1131,7 +1131,9 @@ pub fn load_squadrons(pak: &PakArchive) -> Vec<Squadron> {
             let Some(f) = records.record(id) else { continue };
             let slots: Vec<&str> = f.positional.iter().map(|(_, v)| v.as_str()).collect();
             let members = slots
-                .as_chunks::<4>().0.iter()
+                .as_chunks::<4>()
+                .0
+                .iter()
                 .map(|m| SquadronMember {
                     unit: m[0].to_string(),
                     message_set: text(Some(m[1])),

crates/sylpheed-formats/src/ship_capture.rs

@@ -288,12 +288,12 @@ pub fn parse_drawlog(text: &str) -> Vec<CapturedDraw> {
     let mut consts: Vec<(usize, [f64; 4])> = Vec::new();
 
     let flush = |base: u32,
-                     size: u32,
-                     stride: u32,
-                     pos: &mut Vec<[f32; 3]>,
-                     consts: &[(usize, [f64; 4])],
-                     seen: &mut std::collections::HashSet<u32>,
-                     out: &mut Vec<CapturedDraw>| {
+                 size: u32,
+                 stride: u32,
+                 pos: &mut Vec<[f32; 3]>,
+                 consts: &[(usize, [f64; 4])],
+                 seen: &mut std::collections::HashSet<u32>,
+                 out: &mut Vec<CapturedDraw>| {
         let pos = std::mem::take(pos);
         if base == 0 || stride == 0 || !seen.insert(base) {
             return;

crates/sylpheed-formats/src/vfs.rs

@@ -237,7 +237,9 @@ pub fn decode_text(bytes: &[u8]) -> (String, &'static str) {
 
 fn decode_utf16(bytes: &[u8], big_endian: bool) -> String {
     let units: Vec<u16> = bytes
-        .as_chunks::<2>().0.iter()
+        .as_chunks::<2>()
+        .0
+        .iter()
         .map(|c| {
             if big_endian {
                 u16::from_be_bytes([c[0], c[1]])