fix(ci): resolve cargo fmt drift and doc warnings

- ensemble_translation.rs: cargo fmt reformatted a long match expression
- noricum-ir lib.rs: rustdoc was parsing `Vec<T>` in a doc string as an
  unclosed HTML tag; wrapped the type examples in backticks.
- noricum-core type_contract.rs: intra-doc link `[`MAX_CONTRACT_RETRIES`]`
  pointed at a private constant; downgraded to a plain code span.

All three were promoted to errors by RUSTDOCFLAGS=-D warnings in CI.
Verified locally with `cargo fmt --all -- --check` (exit 0) and
`RUSTDOCFLAGS=-D warnings cargo doc --no-deps --workspace` (exit 0).

Author: JuanMarchetto

crates/noricum-agents/src/ensemble_translation.rs

@@ -141,26 +141,26 @@ pub fn evaluate_candidate(
     estimated_cost_usd: f64,
 ) -> TranslationCandidate {
     // Gate 1: Compilation
-    let (compiles, compiler_errors) = match noricum_tools::compiler::check_rust_compiles(rust_source)
-    {
-        Ok(result) => {
-            let errors: Vec<String> = if !result.success {
-                result
-                    .stderr
-                    .lines()
-                    .filter(|l| l.contains("error"))
-                    .map(String::from)
-                    .collect()
-            } else {
-                Vec::new()
-            };
-            (result.success, errors)
-        }
-        Err(e) => {
-            debug!(error = %e, "compilation check failed for candidate {}", config_label);
-            (false, vec![format!("Compilation check error: {e}")])
-        }
-    };
+    let (compiles, compiler_errors) =
+        match noricum_tools::compiler::check_rust_compiles(rust_source) {
+            Ok(result) => {
+                let errors: Vec<String> = if !result.success {
+                    result
+                        .stderr
+                        .lines()
+                        .filter(|l| l.contains("error"))
+                        .map(String::from)
+                        .collect()
+                } else {
+                    Vec::new()
+                };
+                (result.success, errors)
+            }
+            Err(e) => {
+                debug!(error = %e, "compilation check failed for candidate {}", config_label);
+                (false, vec![format!("Compilation check error: {e}")])
+            }
+        };
 
     // Gate 2: Unsafe counting
     let unsafe_count = noricum_tools::compiler::count_unsafe_blocks(rust_source);
@@ -175,10 +175,7 @@ pub fn evaluate_candidate(
 
     info!(
         label = config_label,
-        compiles,
-        unsafe_count,
-        idiomatic_score,
-        "evaluated ensemble candidate"
+        compiles, unsafe_count, idiomatic_score, "evaluated ensemble candidate"
     );
 
     TranslationCandidate {
@@ -218,27 +215,28 @@ pub fn evaluate_candidate_with_specs(
     // Optional Gate: Spec validation (only if compiles and traces available)
     if candidate.compiles
         && let Some(traces) = traces
-            && !traces.is_empty() {
-                match noricum_tools::spec_mining::validate_against_specs(rust_source, traces) {
-                    Ok(spec_result) => {
-                        candidate.specs_passed = Some(spec_result.passed);
-                        candidate.specs_total = Some(spec_result.total_specs);
-                        info!(
-                            label = config_label,
-                            specs_passed = spec_result.passed,
-                            specs_total = spec_result.total_specs,
-                            "P38: spec validation for ensemble candidate"
-                        );
-                    }
-                    Err(e) => {
-                        debug!(
-                            label = config_label,
-                            error = %e,
-                            "P38: spec validation failed for ensemble candidate"
-                        );
-                    }
-                }
+        && !traces.is_empty()
+    {
+        match noricum_tools::spec_mining::validate_against_specs(rust_source, traces) {
+            Ok(spec_result) => {
+                candidate.specs_passed = Some(spec_result.passed);
+                candidate.specs_total = Some(spec_result.total_specs);
+                info!(
+                    label = config_label,
+                    specs_passed = spec_result.passed,
+                    specs_total = spec_result.total_specs,
+                    "P38: spec validation for ensemble candidate"
+                );
             }
+            Err(e) => {
+                debug!(
+                    label = config_label,
+                    error = %e,
+                    "P38: spec validation failed for ensemble candidate"
+                );
+            }
+        }
+    }
 
     candidate
 }
@@ -707,10 +705,7 @@ mod tests {
     #[test]
     fn test_estimate_candidate_cost_anthropic() {
         let cost = estimate_candidate_cost(1_000_000, 500_000, &ProviderKind::Anthropic);
-        assert!(
-            (cost - 10.5).abs() < 0.01,
-            "expected ~$10.50, got ${cost}"
-        );
+        assert!((cost - 10.5).abs() < 0.01, "expected ~$10.50, got ${cost}");
     }
 
     #[test]
@@ -945,9 +940,30 @@ pub fn hash_key(s: *const u8) -> u64 {
         let c = "unsigned long hash_key(const char *str) { unsigned long hash = 5381; int c; while ((c = *str++)) hash = ((hash << 5) + hash) + c; return hash; }";
 
         let candidates = vec![
-            evaluate_candidate(good_rust, c, "claude-0.3", ProviderKind::Anthropic, 0.3, 0.05),
-            evaluate_candidate(mid_rust, c, "deepseek-0.3", ProviderKind::DeepSeek, 0.3, 0.01),
-            evaluate_candidate(bad_rust, c, "deepseek-0.6", ProviderKind::DeepSeek, 0.6, 0.01),
+            evaluate_candidate(
+                good_rust,
+                c,
+                "claude-0.3",
+                ProviderKind::Anthropic,
+                0.3,
+                0.05,
+            ),
+            evaluate_candidate(
+                mid_rust,
+                c,
+                "deepseek-0.3",
+                ProviderKind::DeepSeek,
+                0.3,
+                0.01,
+            ),
+            evaluate_candidate(
+                bad_rust,
+                c,
+                "deepseek-0.6",
+                ProviderKind::DeepSeek,
+                0.6,
+                0.01,
+            ),
         ];
 
         let compiled_count = candidates.iter().filter(|c| c.compiles).count();

crates/noricum-core/src/type_contract.rs

@@ -29,7 +29,7 @@ You translate C type definitions to idiomatic Rust. You output ONLY valid Rust c
 /// 4. Post-process: strip fences, strip impl blocks
 /// 5. Validate with `check_rust_compiles()`
 /// 6. Try rule engine fixes before LLM retry
-/// 7. Retry up to [`MAX_CONTRACT_RETRIES`] times on failure
+/// 7. Retry up to `MAX_CONTRACT_RETRIES` times on failure
 /// 8. Return `None` if all retries fail (graceful degradation)
 pub async fn generate_type_contract(
     client: &LlmClient,
@@ -59,9 +59,12 @@ pub async fn generate_type_contract(
     };
 
     // Use Easy difficulty — type translation is a focused task
-    let model_sel =
-        select_model(provider_config, noricum_ir::Difficulty::Easy, "type_contract")
-            .map_err(|e| CoreError::Orchestration(format!("P33 model selection: {e}")))?;
+    let model_sel = select_model(
+        provider_config,
+        noricum_ir::Difficulty::Easy,
+        "type_contract",
+    )
+    .map_err(|e| CoreError::Orchestration(format!("P33 model selection: {e}")))?;
     let model = &model_sel.model;
 
     let c_abbreviated = abbreviate_c_for_context(c_source, CONTRACT_C_CONTEXT_MAX_LINES);
@@ -122,10 +125,8 @@ pub async fn generate_type_contract(
                     &result.stderr[..result.stderr.len().min(500)]
                 );
                 // Try mechanical fixes via rule engine before LLM retry
-                let parsed_errors =
-                    noricum_tools::repair_rules::parse_rustc_errors(&result.stderr);
-                let fixed =
-                    noricum_tools::repair_rules::apply_all_rules(&contract, &parsed_errors);
+                let parsed_errors = noricum_tools::repair_rules::parse_rustc_errors(&result.stderr);
+                let fixed = noricum_tools::repair_rules::apply_all_rules(&contract, &parsed_errors);
                 if fixed != contract {
                     match noricum_tools::compiler::check_rust_compiles(&fixed) {
                         Ok(r2) if r2.success => {
@@ -339,9 +340,7 @@ fn strip_impl_blocks(rust_source: &str) -> String {
             i = skip_braced_block_lines(&lines, i);
             continue;
         }
-        if (trimmed.starts_with("pub fn ") || trimmed.starts_with("fn "))
-            && trimmed.contains('(')
-        {
+        if (trimmed.starts_with("pub fn ") || trimmed.starts_with("fn ")) && trimmed.contains('(') {
             if trimmed.contains('{') {
                 i = skip_braced_block_lines(&lines, i);
             } else {
@@ -449,9 +448,14 @@ fn fix_contract_compilation_issues(source: &str) -> String {
 
         // Replace derive(Debug, Clone) → derive(Debug) to avoid E0277 on non-Clone fields
         if trimmed.starts_with("#[derive(") && fixed.contains("Clone") {
-            fixed = fixed.replace(", Clone", "").replace("Clone, ", "").replace("Clone", "Debug");
+            fixed = fixed
+                .replace(", Clone", "")
+                .replace("Clone, ", "")
+                .replace("Clone", "Debug");
             // Deduplicate Debug
-            fixed = fixed.replace("Debug, Debug", "Debug").replace("(Debug, )", "(Debug)");
+            fixed = fixed
+                .replace("Debug, Debug", "Debug")
+                .replace("(Debug, )", "(Debug)");
         }
 
         result.push_str(&fixed);
@@ -707,18 +711,31 @@ pub type MzUint = u32;
         assert!(result.contains("Debug"), "Debug should remain");
 
         // dyn multi-trait → usize
-        assert!(!result.contains("dyn std::io::Read"), "trait objects should be replaced");
+        assert!(
+            !result.contains("dyn std::io::Read"),
+            "trait objects should be replaced"
+        );
         assert!(result.contains("usize"), "should have usize replacements");
 
         // raw pointers → usize
         assert!(!result.contains("*mut"), "raw pointers should be replaced");
 
         // type aliases commented out (not active code)
-        assert!(result.contains("// P33: stripped alias"), "aliases should be commented out");
-        assert!(!result.contains("\npub type MzBool"), "aliases should not be active");
+        assert!(
+            result.contains("// P33: stripped alias"),
+            "aliases should be commented out"
+        );
+        assert!(
+            !result.contains("\npub type MzBool"),
+            "aliases should not be active"
+        );
 
         // Should compile
         let compile = noricum_tools::compiler::check_rust_compiles(&result).unwrap();
-        assert!(compile.success, "Fixed contract should compile: {}", compile.stderr);
+        assert!(
+            compile.success,
+            "Fixed contract should compile: {}",
+            compile.stderr
+        );
     }
 }

crates/noricum-ir/src/lib.rs

@@ -67,7 +67,7 @@ pub enum SemanticHint {
         kind: String,
         /// C functions/structs involved
         involved: Vec<String>,
-        /// Suggested Rust type (e.g., "Vec<T>", "HashMap<K, V>", "BTreeMap<K, V>")
+        /// Suggested Rust type (e.g., `Vec<T>`, `HashMap<K, V>`, `BTreeMap<K, V>`)
         rust_type: String,
     },
     /// Algorithm pattern detected