fix: unbreak rust-ci Test job (clippy 1.95 + missing fields) (#38)

## Summary

`cargo clippy --all-targets --all-features -- -D warnings` and `cargo
test` were both red on `main` after the toolchain rolled to **Rust
1.95.0** and **two struct fields** (`CrashReport::schema_version`,
`ProgramStatistics::safe_unwrap_calls`) were added in v2.5.0 without
updating every test/bench literal.

This PR unblocks the `Test` job in `rust-ci` reusable.

### Lib clippy fixes (5 sites)

| File | Lint | Fix |
|------|------|-----|
| `src/assemblyline.rs:435` | `unnecessary_sort_by` | `sort_by_key(\|r\|
Reverse(...))` |
| `src/bridge/lockfile.rs:23` | `type_complexity` | `type LockfileParser
= fn(&Path) -> Result<...>` |
| `src/bridge/registry.rs:71` | `new_without_default` | `impl Default
for MitigationRegistry` forwarding to `new()` |
| `src/mass_panic/imaging.rs:201` | `unnecessary_sort_by` |
`sort_by_key(\|c\| Reverse(...))` |
| `src/storage/mod.rs:586` | `needless_range_loop` | `for (attempt,
delay) in delays.iter().enumerate()` |

Plus 9 lints already auto-fixed by `cargo clippy --fix`
(`unnecessary_map_or`, `manual_range_contains`, `format_in_format_args`,
`single_component_path_imports`) across `src/assail/analyzer.rs`,
`src/bridge/{lockfile,reachability}.rs`, `src/main.rs`,
`src/storage/mod.rs`, `tests/seam_contract_tests.rs`.

### Test/bench fixes (6 sites)

- `tests/panll_tests.rs:222` — add `CrashReport.schema_version` field
- `tests/report_tests.rs:62` — same
- `tests/panll_tests.rs:247` — `map_or(false, ..)` → `is_some_and(..)`
- `tests/aspect_tests.rs:230` — `|path| f(path)` → `f` (redundant
closure)
- `tests/property_tests.rs:137` — `if let Some(_) = ..` → `.is_some()`
- `tests/property_tests.rs:260` — `vec![..]` → `[..]` (useless_vec)
- `tests/property_tests.rs:325` — replaced tautological `!is_empty()` on
const with `chars().count() > 0` (still exercises unicode-iteration
smoke check)
- `benches/scan_bench.rs:8/221` — `criterion::black_box` →
`std::hint::black_box` (deprecated); add `safe_unwrap_calls: 0` to
`ProgramStatistics` literal

### Overlap with PR #36

The `tests/seam_contract_tests.rs:433/490` fmt collapses overlap with PR
#36 (identical fix). Whichever lands second will be a no-op merge.

## Test plan

- [x] `cargo clippy --all-targets --all-features -- -D warnings` clean
- [x] `cargo fmt --check` clean
- [x] `cargo test --all-features --no-fail-fast` — all suites green
(218+218+... pass)
- [x] Signed commit, MPL-2.0 headers untouched
- [x] No semantic changes, no new API surface, no feature changes

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

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

benches/scan_bench.rs

@@ -5,8 +5,9 @@
 //!
 //! Measures: language detection, pattern matching, full analysis pipeline.
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{criterion_group, criterion_main, Criterion};
 use panic_attack::types::Language;
+use std::hint::black_box;
 
 /// Benchmark language detection from file extension
 fn bench_language_detect(c: &mut Criterion) {
@@ -223,6 +224,7 @@ fn bench_statistics_calculation(c: &mut Criterion) {
             unsafe_blocks: 5,
             panic_sites: 0,
             unwrap_calls: 50,
+            safe_unwrap_calls: 0,
             allocation_sites: 12,
             io_operations: 4,
             threading_constructs: 3,

src/assail/analyzer.rs

@@ -3966,7 +3966,7 @@ impl Analyzer {
 
             // Detect function definitions
             if line.trim().starts_with("fn ") && !line.trim().starts_with("fn test") {
-                if let Some(func_name) = line.trim().split_whitespace().nth(1) {
+                if let Some(func_name) = line.split_whitespace().nth(1) {
                     let func_name = func_name.split('(').next().unwrap_or(func_name);
                     current_function = func_name.to_string();
                     function_calls
@@ -5174,12 +5174,11 @@ impl Analyzer {
                     }
                 }
 
-                Language::Erlang => {
-                    if content.contains("-behaviour(gen_server)")
-                        || content.contains("-behaviour(supervisor)")
-                    {
-                        frameworks.insert(Framework::OTP);
-                    }
+                Language::Erlang
+                    if (content.contains("-behaviour(gen_server)")
+                        || content.contains("-behaviour(supervisor)")) =>
+                {
+                    frameworks.insert(Framework::OTP);
                 }
 
                 Language::Go => {
@@ -6007,7 +6006,7 @@ func main() {
                     && wp
                         .location
                         .as_deref()
-                        .map_or(false, |loc| loc.contains("node_modules"))
+                        .is_some_and(|loc| loc.contains("node_modules"))
             })
             .collect();
 

src/assemblyline.rs

@@ -432,7 +432,7 @@ pub fn run_with_cache(
         .count();
 
     // Sort by weak point count descending (riskiest repos first)
-    results.sort_by(|a, b| b.weak_point_count.cmp(&a.weak_point_count));
+    results.sort_by_key(|r| std::cmp::Reverse(r.weak_point_count));
 
     // Apply filters
     if config.findings_only {

src/bridge/lockfile.rs

@@ -17,10 +17,12 @@ use std::path::Path;
 /// order. All successful parses are merged into a single list. Errors from
 /// individual parsers are logged as warnings and skipped so one malformed
 /// lockfile does not abort triage of the whole project.
+type LockfileParser = fn(&Path) -> Result<Vec<LockedDependency>>;
+
 pub fn discover_and_parse(dir: &Path) -> Vec<LockedDependency> {
     let mut all = Vec::new();
 
-    let candidates: &[(&str, fn(&Path) -> Result<Vec<LockedDependency>>)] = &[
+    let candidates: &[(&str, LockfileParser)] = &[
         ("Cargo.lock", parse_cargo_lock),
         ("mix.lock", parse_mix_lock),
         ("package-lock.json", parse_package_lock_json),
@@ -66,7 +68,7 @@ pub fn parse_cargo_lock(path: &Path) -> Result<Vec<LockedDependency>> {
             if let (Some(name), Some(version)) = (current_name.take(), current_version.take()) {
                 if current_source
                     .as_ref()
-                    .map_or(false, |s| s.contains("registry"))
+                    .is_some_and(|s| s.contains("registry"))
                 {
                     deps.push(LockedDependency {
                         name,
@@ -94,7 +96,7 @@ pub fn parse_cargo_lock(path: &Path) -> Result<Vec<LockedDependency>> {
     if let (Some(name), Some(version)) = (current_name, current_version) {
         if current_source
             .as_ref()
-            .map_or(false, |s| s.contains("registry"))
+            .is_some_and(|s| s.contains("registry"))
         {
             deps.push(LockedDependency {
                 name,

src/bridge/reachability.rs

@@ -54,7 +54,7 @@ pub fn check_reachability(project_dir: &Path, crate_name: &str) -> Result<Reacha
         }
 
         let path = entry.path();
-        if path.extension().map_or(true, |ext| ext != "rs") {
+        if path.extension().is_none_or(|ext| ext != "rs") {
             continue;
         }
 

src/bridge/registry.rs

@@ -68,6 +68,12 @@ pub struct MitigationRegistry {
     pub entries: Vec<MitigationEntry>,
 }
 
+impl Default for MitigationRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl MitigationRegistry {
     /// Create an empty registry.
     pub fn new() -> Self {

src/main.rs

@@ -2250,8 +2250,8 @@ fn run_main() -> Result<()> {
                         println!("Run `panic-attack bridge triage --register` to populate.");
                     } else {
                         println!(
-                            "{:<12} {:<20} {:<15} {:<15} {}",
-                            "ID", "ADVISORY", "PACKAGE", "STATUS", "ACTION"
+                            "{:<12} {:<20} {:<15} {:<15} ACTION",
+                            "ID", "ADVISORY", "PACKAGE", "STATUS"
                         );
                         println!("{}", "-".repeat(80));
                         for entry in &registry.entries {

src/mass_panic/imaging.rs

@@ -198,7 +198,7 @@ pub fn build_image(report: &AssemblylineReport) -> SystemImage {
                 .into_iter()
                 .map(|(name, count)| CategoryCount { name, count })
                 .collect();
-            cats.sort_by(|a, b| b.count.cmp(&a.count));
+            cats.sort_by_key(|c| std::cmp::Reverse(c.count));
             cats
         } else {
             Vec::new()

src/storage/mod.rs

@@ -451,7 +451,7 @@ pub fn push_hexad_http(hexad: &PanicAttackHexad, gateway_url: &str) -> Result<St
     let status = response.status().as_u16();
     let body = read_body(response);
 
-    if status >= 200 && status < 300 {
+    if (200..300).contains(&status) {
         Ok(body)
     } else {
         Err(anyhow!("VeriSimDB returned {}: {}", status, body))
@@ -580,16 +580,16 @@ pub fn push_hexad_http_with_retry(hexad: &PanicAttackHexad, gateway_url: &str) -
         std::time::Duration::from_secs(2),
         std::time::Duration::from_secs(4),
     ];
-    let max_attempts: usize = 3;
+    let max_attempts = delays.len();
     let mut last_err: Option<anyhow::Error> = None;
 
-    for attempt in 0..max_attempts {
+    for (attempt, delay) in delays.iter().enumerate() {
         match push_hexad_http(hexad, gateway_url) {
             Ok(body) => return Ok(body),
             Err(e) => {
                 last_err = Some(e);
                 if attempt < max_attempts - 1 {
-                    std::thread::sleep(delays[attempt]);
+                    std::thread::sleep(*delay);
                 }
             }
         }
@@ -632,7 +632,7 @@ pub fn push_hexads_batch(hexads: &[PanicAttackHexad], gateway_url: &str) -> Resu
                     results.push(body);
                 }
                 Ok(results)
-            } else if status >= 200 && status < 300 {
+            } else if (200..300).contains(&status) {
                 Ok(vec![read_body(response)])
             } else {
                 let body = read_body(response);
@@ -669,7 +669,7 @@ pub fn query_hexads(gateway_url: &str, limit: usize) -> Result<Vec<PanicAttackHe
     let status = response.status().as_u16();
     let body = read_body(response);
 
-    if status >= 200 && status < 300 {
+    if (200..300).contains(&status) {
         let hexads: Vec<PanicAttackHexad> = serde_json::from_str(&body)
             .map_err(|e| anyhow!("Failed to parse VeriSimDB response: {}", e))?;
         Ok(hexads)
@@ -708,7 +708,7 @@ pub fn check_gateway(gateway_url: &str) -> bool {
     let is_healthy = match builder.call() {
         Ok(resp) => {
             let s = resp.status().as_u16();
-            s >= 200 && s < 300
+            (200..300).contains(&s)
         }
         Err(_) => false,
     };

tests/aspect_tests.rs

@@ -227,7 +227,7 @@ fn aspect_parallel_analysis_correctness() {
         .collect();
 
     // Using rayon parallel iterator (same as assemblyline)
-    let _results: Vec<_> = files.par_iter().map(|path| assail::analyze(path)).collect();
+    let _results: Vec<_> = files.par_iter().map(assail::analyze).collect();
 
     // Should complete without data races or panics
     // (In practice, rayon + Rust's type system ensure this)