style(rust-cli): fix clippy 1.97 + rustfmt for CI green

CI (Rust 1.97) failed two checks on this branch:
- rustfmt: new test files + the Obliterate executor arm needed formatting.
- clippy -D warnings: unneeded_wildcard_pattern (field: _ redundant with ..)
  in commands.rs (Chmod/Chown) and parser.rs (External/Touch), which clippy
  1.97 newly errors on; plus a pre-existing let_and_return in the ${VAR:=default}
  expansion path.

Fixes:
- cargo fmt across the crate (new tests + executable.rs).
- Remove redundant  bindings where  already covers them.
- Inline the let-and-return in AssignDefault expansion (behavior unchanged).

Verified against CI's exact toolchain: cargo +1.97.0 clippy --all-targets
--all-features -- -D warnings is clean; cargo +1.97.0 fmt --check has 0 diffs.
Full lib suite (317) + obliterate RMO tests (6) still green.

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

Author: claude

impl/rust-cli/src/commands.rs

@@ -2233,8 +2233,7 @@ pub fn explain_command(cmd: &crate::parser::Command, state: &ShellState) -> Resu
                 resolved.display()
             );
         }
-        crate::parser::Command::Chmod { path: _, .. }
-        | crate::parser::Command::Chown { path: _, .. } => {
+        crate::parser::Command::Chmod { .. } | crate::parser::Command::Chown { .. } => {
             // Outer arm guarantees we are in {Chmod, Chown}; the inner match
             // exists only to extract the `path` field uniformly. Any other
             // variant here is a structural bug, surfaced as typed error.

impl/rust-cli/src/executable.rs

@@ -129,7 +129,12 @@ impl ExecutableCommand for Command {
             } => {
                 let expanded_path = crate::parser::expand_variables(path, state);
                 if redirects.is_empty() {
-                    commands::secure_deletion::obliterate_path(state, &expanded_path, false, *force)?;
+                    commands::secure_deletion::obliterate_path(
+                        state,
+                        &expanded_path,
+                        false,
+                        *force,
+                    )?;
                 } else {
                     redirection::capture_and_redirect(redirects, state, |s| {
                         commands::secure_deletion::obliterate_path(s, &expanded_path, false, *force)

impl/rust-cli/src/parser.rs

@@ -2264,10 +2264,9 @@ fn apply_expansion(expansion: &ParameterExpansion, state: &crate::state::ShellSt
             // TODO: Assignment not implemented - requires mutable state
             // For v1.1.0, just return default without assigning (like Default)
             if is_unset || (*check_null && is_null) {
-                let default_expanded = expand_variables(value, state);
-                // Note: In bash, this would also assign to VAR
+                // Note: In bash, this would also assign to VAR.
                 // Requires signature change: &mut ShellState
-                default_expanded
+                expand_variables(value, state)
             } else {
                 // var_value is Some by construction here: the surrounding
                 // `if is_unset || ...` branch is the unset/null path; this
@@ -4346,7 +4345,7 @@ mod tests {
         // Test using $1 in a command
         let cmd = parse_command("touch $1").unwrap();
         match cmd {
-            Command::External { args: _, .. } | Command::Touch { path: _, .. } => {
+            Command::External { .. } | Command::Touch { .. } => {
                 // After parsing, before execution, $1 should still be present
                 // Expansion happens during execution
             }

impl/rust-cli/tests/model_oracle_correspondence.rs

@@ -131,7 +131,10 @@ fn gen_sequence(rng: &mut Rng, max_ops: usize) -> (Vec<Op>, Vec<String>) {
             }
             shadow.insert(p.clone(), Kind::Dir);
             touched.insert(p.clone(), ());
-            ops.push(Op { verb: "MKDIR", path: p });
+            ops.push(Op {
+                verb: "MKDIR",
+                path: p,
+            });
         } else if roll < 8 {
             // TOUCH under an existing directory
             let ds = dirs(&shadow);
@@ -143,7 +146,10 @@ fn gen_sequence(rng: &mut Rng, max_ops: usize) -> (Vec<Op>, Vec<String>) {
             }
             shadow.insert(p.clone(), Kind::File);
             touched.insert(p.clone(), ());
-            ops.push(Op { verb: "TOUCH", path: p });
+            ops.push(Op {
+                verb: "TOUCH",
+                path: p,
+            });
         } else if roll < 9 {
             // RM an existing file
             let files: Vec<String> = shadow
@@ -157,7 +163,10 @@ fn gen_sequence(rng: &mut Rng, max_ops: usize) -> (Vec<Op>, Vec<String>) {
             let p = files[rng.below(files.len())].clone();
             shadow.remove(&p);
             touched.insert(p.clone(), ());
-            ops.push(Op { verb: "RM", path: p });
+            ops.push(Op {
+                verb: "RM",
+                path: p,
+            });
         } else {
             // RMDIR an empty directory
             let empties: Vec<String> = shadow
@@ -171,7 +180,10 @@ fn gen_sequence(rng: &mut Rng, max_ops: usize) -> (Vec<Op>, Vec<String>) {
             let p = empties[rng.below(empties.len())].clone();
             shadow.remove(&p);
             touched.insert(p.clone(), ());
-            ops.push(Op { verb: "RMDIR", path: p });
+            ops.push(Op {
+                verb: "RMDIR",
+                path: p,
+            });
         }
     }
 
@@ -260,7 +272,10 @@ fn rust_matches_proven_lean_model() {
                 _ => unreachable!(),
             };
             r.unwrap_or_else(|e| {
-                panic!("seq {seq}: generated op {} {} rejected by impl: {e}", op.verb, op.path)
+                panic!(
+                    "seq {seq}: generated op {} {} rejected by impl: {e}",
+                    op.verb, op.path
+                )
             });
         }
 
@@ -278,11 +293,14 @@ fn rust_matches_proven_lean_model() {
         for (probe, model_kind) in probes.iter().zip(model.iter()) {
             let impl_kind = rust_kind(temp.path(), probe);
             assert_eq!(
-                model_kind, impl_kind,
+                model_kind,
+                impl_kind,
                 "CORRESPONDENCE DIVERGENCE (seq {seq}) at '{probe}': \
                  proven Lean model says {model_kind}, Rust impl says {impl_kind}.\n\
                  ops: {:?}",
-                ops.iter().map(|o| format!("{} {}", o.verb, o.path)).collect::<Vec<_>>()
+                ops.iter()
+                    .map(|o| format!("{} {}", o.verb, o.path))
+                    .collect::<Vec<_>>()
             );
             checked_probes += 1;
         }
@@ -292,5 +310,7 @@ fn rust_matches_proven_lean_model() {
         checked_probes > 0,
         "no probes were checked — generator produced only empty sequences"
     );
-    eprintln!("model_oracle_correspondence: {checked_probes} probes agreed across {SEQUENCES} sequences");
+    eprintln!(
+        "model_oracle_correspondence: {checked_probes} probes agreed across {SEQUENCES} sequences"
+    );
 }

impl/rust-cli/tests/obliterate_rmo_tests.rs

@@ -33,7 +33,10 @@ fn obliterate_is_wired_into_dispatch() {
     }
 
     // --force before or after the path both work.
-    for input in ["obliterate --force secret.txt", "obliterate secret.txt --force"] {
+    for input in [
+        "obliterate --force secret.txt",
+        "obliterate secret.txt --force",
+    ] {
         match parse_command(input).expect("parse") {
             Command::Obliterate { path, force, .. } => {
                 assert_eq!(path, "secret.txt", "input: {input}");
@@ -79,7 +82,10 @@ fn obliterate_writes_rmo_audit_residue() {
         .expect("execute");
 
     let audit = temp.path().join(".vsh-audit.log");
-    assert!(audit.exists(), "RMO audit residue must be written to the sandbox");
+    assert!(
+        audit.exists(),
+        "RMO audit residue must be written to the sandbox"
+    );
     let contents = fs::read_to_string(&audit).expect("read audit");
     assert!(
         contents.contains("Obliterate"),
@@ -130,5 +136,8 @@ fn obliterate_then_recreate_has_no_old_content() {
     fs::write(&p, b"fresh").expect("rewrite");
     let back = fs::read(&p).expect("read");
     assert_eq!(back, b"fresh");
-    assert!(!back.windows(4).any(|w| w == b"4111"), "no old plaintext remains");
+    assert!(
+        !back.windows(4).any(|w| w == b"4111"),
+        "no old plaintext remains"
+    );
 }