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

`cargo clippy --all-targets --all-features -- -D warnings` and
`cargo test` were both red on main:

* clippy 1.95.0 surfaced new lints across lib/tests/bench:
  unnecessary_map_or, manual_range_contains, unnecessary_sort_by,
  needless_range_loop, type_complexity, new_without_default,
  redundant_closure, redundant_pattern_matching, useless_vec,
  len_zero, const_is_empty, format_in_format_args.
* `criterion::black_box` is deprecated in favour of `std::hint::black_box`.
* `tests/panll_tests.rs` + `tests/report_tests.rs` constructed
  `CrashReport` without the (non-default) `schema_version` field that
  was added in v2.5; `benches/scan_bench.rs` constructed
  `ProgramStatistics` without `safe_unwrap_calls`.

All edits are semantic identities: sort_by → sort_by_key + Reverse,
needless range-loop → enumerate-over-iter, fn-pointer column →
type alias, MitigationRegistry::new() → Default impl forwarding,
`(200..300).contains(&status)` for HTTP status check, `is_some_and`
in place of `map_or(false, ...)`, etc.

The `tests/seam_contract_tests.rs` fmt collapses on lines 433/490
overlap with PR #36 (same fix) — second to land will be a no-op.

Estate guardrail: no Python, no PMPL-1.0, signed commit, MSRV-safe
identities only (no new API surface, no feature changes).

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)