fix(lint): clear the clippy backlog the revived Rust CI exposed (#361)

## Why main is currently red

PR #358 revived Rust CI. It merged **before** this commit landed on the
branch, so main
now has a *working* Rust CI that immediately fails its `Cargo check +
clippy + fmt` step.

That is not a regression — it is the gate doing its job for the first
time since
2026-06-27. This PR is the backlog it found.

Current state of the revived gate on main (`d7f1b49`):

```
success  wasm-tools validate (emitted modules)
success  Cargo build + test (ephapax-cli, --no-default-features)
success  rust-ci / Detect Cargo.toml
failure  rust-ci / Cargo check + clippy + fmt     <-- this PR
```

## What this fixes

`cargo clippy --all-targets -- -D warnings` failed crate after crate.
All resolved;
it now exits 0.

**Mechanical, behaviour-preserving:**

| Lint | Fix |
|---|---|
| `derivable_impls` | `impl Default for Visibility` →
`#[derive(Default)]` + `#[default]` |
| `manual_try_fold` ×2 | `.fold(Ok(acc), ..)` → `.try_fold(acc, ..)` in
the surface and core parsers' statement-sequence desugaring |
| `collapsible_if` ×2, `match_like_matches_macro` | via `cargo clippy
--fix` |
| `ptr_arg` | `&PathBuf` → `&Path` in two `ephapax-cli` signatures |
| `unnecessary_unsafe` | removed an **empty** `unsafe {}` block wrapping
only comments in a placeholder test |

That last one is worth a second look in a language whose entire thesis
is memory safety:
`ephapax-runtime::list::tests::test_list_new` contained `unsafe { /*
comments only */ }`.

**Deliberately allowed, each with an inline reason** (no blanket
crate-level allow):

- `approx_constant` — `lex("3.14")` is a float literal *under test*, not
an approximation of PI
- `type_complexity` — replaced with a `TokenPredicate` type alias
- `too_many_arguments` ×3 — 8 params vs clippy's default threshold of 7,
on option-heavy CLI
  entry points and the recursive import resolver
- `large_enum_variant` — `Value::Closure` is ~264 bytes vs ~48 for the
next largest, so every
`Value` pays for it. The real fix is boxing the payload, which touches
every construction
and match site **in the interpreter**. That is a behavioural-risk
refactor that does not
belong in a CI-infrastructure change. Allowed here with a comment,
tracked in **#360**.

## Verification — all local, all green

```
cargo check --locked --all-targets          ok
cargo clippy --all-targets -- -D warnings   exit 0
cargo fmt --all -- --check                  clean
cargo test --workspace                      285 passed, 0 failed
```

The 285 passing tests matter here: the `try_fold` rewrites and the
`unsafe` removal are the
only changes that could alter behaviour, and the parser/interpreter
suites cover both.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: hyperpolymath

ephapax-linear/src/tests.rs

@@ -383,7 +383,7 @@ fn p2p_single_consume_always_accepted_both_disciplines() {
         let expr = e(ExprKind::LetLin {
             name: name.clone().into(),
             ty: Some(Ty::Base(BaseTy::I32)),
-            value: Box::new(i32_lit(i as i32)),
+            value: Box::new(i32_lit(i)),
             body: Box::new(var(&name)),
         });
 
@@ -413,7 +413,7 @@ fn p2p_contraction_always_rejected_both_disciplines() {
         let expr = e(ExprKind::LetLin {
             name: name.clone().into(),
             ty: Some(Ty::Base(BaseTy::I32)),
-            value: Box::new(i32_lit(i as i32)),
+            value: Box::new(i32_lit(i)),
             body: Box::new(e(ExprKind::Pair {
                 left: Box::new(var(&name)),
                 right: Box::new(var(&name)),
@@ -462,7 +462,7 @@ fn p2p_weakening_linear_forbidden_affine_allowed() {
         let expr = e(ExprKind::LetLin {
             name: name.clone().into(),
             ty: Some(Ty::Base(BaseTy::I32)),
-            value: Box::new(i32_lit(i as i32)),
+            value: Box::new(i32_lit(i)),
             body: Box::new(unit()),
         });
 
@@ -485,7 +485,7 @@ fn p2p_weakening_linear_forbidden_affine_allowed() {
         let affine_expr = e(ExprKind::Let {
             name: name.clone().into(),
             ty: Some(Ty::Base(BaseTy::I32)),
-            value: Box::new(i32_lit(i as i32)),
+            value: Box::new(i32_lit(i)),
             body: Box::new(unit()),
         });
         let mut affine = AffineChecker::new();
@@ -510,7 +510,7 @@ fn p2p_unified_api_consistent_with_direct_checkers() {
         let good_expr = e(ExprKind::LetLin {
             name: name.clone().into(),
             ty: Some(Ty::Base(BaseTy::I32)),
-            value: Box::new(i32_lit(i as i32)),
+            value: Box::new(i32_lit(i)),
             body: Box::new(var(&name)),
         });
 

src/ephapax-cli/src/import_resolver.rs

@@ -162,6 +162,7 @@ fn first_module_declaration(source: &str) -> Option<String> {
     None
 }
 
+#[allow(clippy::too_many_arguments)] // recursive resolver: 8 params vs the 7 default threshold
 fn visit(
     logical: &str,
     explicit_file: Option<&Path>,

src/ephapax-cli/src/main.rs

@@ -419,8 +419,9 @@ fn check_files(files: &[PathBuf], _mode_str: &str, verbose: bool) -> Result<(),
     }
 }
 
+#[allow(clippy::too_many_arguments)] // CLI entry point: 8 options vs the 7 default threshold
 fn compile_file(
-    path: &PathBuf,
+    path: &Path,
     output: Option<PathBuf>,
     opt_level: u8,
     debug: bool,
@@ -570,10 +571,11 @@ fn compile_file(
 
 /// Codegen + optional ownership verification + output write. Shared by
 /// the multi-module and legacy single-file compile paths.
+#[allow(clippy::too_many_arguments)] // CLI entry point: 8 options vs the 7 default threshold
 fn finish_compile(
     module: ephapax_syntax::Module,
     filename: &str,
-    path: &PathBuf,
+    path: &Path,
     output: Option<PathBuf>,
     opt_level: u8,
     debug: bool,

src/ephapax-cli/tests/integration.rs

@@ -32,9 +32,8 @@ fn assert_checks(source: &str) {
 
 /// Helper: assert that source fails type-checking
 fn assert_rejects(source: &str) {
-    match check(source) {
-        Ok(ty) => panic!("Expected type-check failure for `{source}`, got: {ty:?}"),
-        Err(_) => {}
+    if let Ok(ty) = check(source) {
+        panic!("Expected type-check failure for `{source}`, got: {ty:?}")
     }
 }
 

src/ephapax-desugar/src/lib.rs

@@ -87,10 +87,7 @@ fn module_qualifier_of(base: &SurfaceExpr) -> Option<SmolStr> {
 /// (`lib/math` → `math`, `Foo.Bar` → `Bar`, `Coproc` → `Coproc`). This is
 /// the name a `M.member` qualifier must use.
 fn last_segment(path: &str) -> SmolStr {
-    path.rsplit(|c| c == '/' || c == '.')
-        .next()
-        .unwrap_or(path)
-        .into()
+    path.rsplit(['/', '.']).next().unwrap_or(path).into()
 }
 
 /// Desugaring errors.
@@ -2014,7 +2011,7 @@ mod tests {
                     assert_eq!(params[0].0.as_str(), "title");
                     assert_eq!(*ret_ty, Ty::Base(BaseTy::I32));
                 } else {
-                    panic!("expected ExternItem::Fn, got {:?}", &items[1]);
+                    panic!("expected ExternItem::Fn, got {:?}", items[1]);
                 }
             }
             other => panic!("expected Decl::Extern, got {other:?}"),

src/ephapax-interp/src/lib.rs

@@ -106,6 +106,13 @@ pub enum RuntimeError {
 }
 
 /// Runtime values
+//
+// clippy::large_enum_variant — `Closure` is ~264 bytes against ~48 for the next
+// largest variant. The fix is to box the closure payload, but that changes every
+// construction and match site in the interpreter, so it is deliberately NOT bundled
+// into the CI-revival change that first surfaced this lint. Tracked separately;
+// remove this allow when the boxing lands.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum Value {
     Unit,

src/ephapax-lexer/src/lib.rs

@@ -584,6 +584,8 @@ mod tests {
         assert_eq!(lex("12345"), vec![TokenKind::Integer(12345)]);
     }
 
+    // `3.14` here is a float literal under test, not an approximation of PI.
+    #[allow(clippy::approx_constant)]
     #[test]
     fn test_floats() {
         assert_eq!(lex("3.14"), vec![TokenKind::Float(3.14)]);
@@ -785,6 +787,9 @@ mod tests {
 mod property_tests {
     use super::*;
 
+    /// Predicate over a token kind, used by the table-driven P2P tests.
+    type TokenPredicate = fn(&TokenKind) -> bool;
+
     // -------------------------------------------------------------------------
     // P2P: round-trip token spans
     // -------------------------------------------------------------------------
@@ -891,7 +896,7 @@ mod property_tests {
     /// exactly one content token of the Integer kind.
     #[test]
     fn p2p_integer_literals_tokenise_to_one_token() {
-        let inputs: Vec<(&str, fn(&TokenKind) -> bool)> = vec![
+        let inputs: Vec<(&str, TokenPredicate)> = vec![
             ("0", |t| matches!(t, TokenKind::Integer(_))),
             ("1", |t| matches!(t, TokenKind::Integer(_))),
             ("42", |t| matches!(t, TokenKind::Integer(_))),

src/ephapax-lsp/src/main.rs

@@ -173,11 +173,7 @@ impl Backend {
         if let Some(module) = &state.module {
             for d in &module.decls {
                 if let Decl::Fn {
-                    name,
-                    body,
-                    params,
-                    type_params: _,
-                    ..
+                    name, body, params, ..
                 } = d
                 {
                     // Check if word matches a parameter
@@ -572,7 +568,7 @@ fn extract_declarations(module: &Module, _source: &str) -> Vec<DeclInfo> {
                         .unwrap_or_default()
                 ),
                 params: Vec::new(),
-                return_type: ty.as_ref().map(|t| format_ty(t)),
+                return_type: ty.as_ref().map(format_ty),
             }),
             Decl::Extern { abi, items } => {
                 for item in items {

src/ephapax-parser/src/lib.rs

@@ -287,10 +287,8 @@ fn parse_extern_item(pair: pest::iterators::Pair<Rule>) -> Result<ExternItem, Pa
                             }
                         }
                     }
-                    Rule::ty => {
-                        if ret_ty.is_none() {
-                            ret_ty = Some(parse_type(sub)?);
-                        }
+                    Rule::ty if ret_ty.is_none() => {
+                        ret_ty = Some(parse_type(sub)?);
                     }
                     _ => {}
                 }
@@ -772,8 +770,7 @@ fn parse_seq_expr_core(pair: pest::iterators::Pair<Rule>) -> Result<Expr, ParseE
 
     // invariant: loop above ensures parsed is not empty before we enter this block
     let last = parsed.pop().expect("invariant: parsed is not empty");
-    parsed.into_iter().rev().fold(Ok(last), |acc, expr| {
-        let acc = acc?;
+    parsed.into_iter().rev().try_fold(last, |acc, expr| {
         let s = expr.span;
         Ok(Expr::new(
             ExprKind::Let {
@@ -1261,34 +1258,29 @@ fn parse_handle_expr(pair: pest::iterators::Pair<Rule>) -> Result<Expr, ParseErr
                     match item.as_rule() {
                         Rule::handler_param_list => {
                             for param_item in item.into_inner() {
-                                match param_item.as_rule() {
-                                    Rule::handler_param => {
-                                        let hp_inner = param_item.into_inner().next();
-                                        if let Some(hp) = hp_inner {
-                                            match hp.as_rule() {
-                                                Rule::resume_param => {
-                                                    // Check for mode
-                                                    if let Some(mode_pair) = hp.into_inner().next()
-                                                    {
-                                                        resume_mode =
-                                                            Some(match mode_pair.as_str() {
-                                                                "once" => ResumeMode::Once,
-                                                                "multi" => ResumeMode::Multi,
-                                                                _ => ResumeMode::Once,
-                                                            });
-                                                    } else {
-                                                        resume_mode = Some(ResumeMode::Once);
-                                                        // default
-                                                    }
-                                                }
-                                                Rule::identifier => {
-                                                    params.push(parse_identifier(hp));
+                                if param_item.as_rule() == Rule::handler_param {
+                                    let hp_inner = param_item.into_inner().next();
+                                    if let Some(hp) = hp_inner {
+                                        match hp.as_rule() {
+                                            Rule::resume_param => {
+                                                // Check for mode
+                                                if let Some(mode_pair) = hp.into_inner().next() {
+                                                    resume_mode = Some(match mode_pair.as_str() {
+                                                        "once" => ResumeMode::Once,
+                                                        "multi" => ResumeMode::Multi,
+                                                        _ => ResumeMode::Once,
+                                                    });
+                                                } else {
+                                                    resume_mode = Some(ResumeMode::Once);
+                                                    // default
                                                 }
-                                                _ => {}
                                             }
+                                            Rule::identifier => {
+                                                params.push(parse_identifier(hp));
+                                            }
+                                            _ => {}
                                         }
                                     }
-                                    _ => {}
                                 }
                             }
                         }
@@ -2359,7 +2351,7 @@ mod tests {
                     assert_eq!(name.as_str(), "window_open");
                     assert_eq!(params.len(), 2);
                 } else {
-                    panic!("expected ExternItem::Fn, got {:?}", &items[1]);
+                    panic!("expected ExternItem::Fn, got {:?}", items[1]);
                 }
             }
             other => panic!("expected Decl::Extern, got {other:?}"),

src/ephapax-parser/src/surface.rs

@@ -201,10 +201,8 @@ fn parse_extern_item(pair: pest::iterators::Pair<Rule>) -> Result<SurfaceExternI
                             }
                         }
                     }
-                    Rule::ty => {
-                        if ret_ty.is_none() {
-                            ret_ty = Some(parse_type(sub)?);
-                        }
+                    Rule::ty if ret_ty.is_none() => {
+                        ret_ty = Some(parse_type(sub)?);
                     }
                     _ => {}
                 }
@@ -507,8 +505,7 @@ fn parse_seq_expr(pair: pest::iterators::Pair<Rule>) -> Result<SurfaceExpr, Pars
     //   let _ = e1 in (let _ = e2 in (... eN))
     // invariant: loop above ensures parsed is not empty before we enter this block
     let last = parsed.pop().expect("invariant: parsed is not empty");
-    parsed.into_iter().rev().fold(Ok(last), |acc, expr| {
-        let acc = acc?;
+    parsed.into_iter().rev().try_fold(last, |acc, expr| {
         let s = expr.span;
         Ok(SurfaceExpr::new(
             SurfaceExprKind::Let {