TDD: fix hotspot line_range off-by-one and return type regex matching wrong arrow

- multi_pass.rs: max_line used new_start + new_lines (1 past end), now uses saturating_sub(1)
- code_summary.rs: extract_return_type matched first -> (inside fn pointer params),
  now uses greedy .* to match the last -> (the actual return type arrow)

332 tests, 0 warnings, 0 clippy issues.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

src/core/code_summary.rs

@@ -259,11 +259,13 @@ fn extract_parameters(code: &str, language: &str) -> Vec<String> {
 }
 
 static RUST_RETURN: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"->\s*([^\{]+)").unwrap());
+    Lazy::new(|| Regex::new(r".*->\s*([^\{]+)").unwrap());
 
 fn extract_return_type(code: &str, language: &str) -> Option<String> {
     match language {
         "rs" => {
+            // Greedy .* consumes everything up to the LAST "->", which is
+            // the return type arrow (skips arrows inside fn pointer params)
             let first_lines: String = code.lines().take(3).collect::<Vec<_>>().join(" ");
             RUST_RETURN
                 .captures(&first_lines)
@@ -743,6 +745,21 @@ mod tests {
         );
     }
 
+    // BUG: extract_return_type matches first "->" in the line, which hits the
+    // arrow inside fn pointer params instead of the actual return type arrow
+    #[test]
+    fn test_extract_return_type_with_fn_pointer_param() {
+        let code = "fn process(cb: fn(u32) -> bool) -> Result<()> {";
+        let ret = extract_return_type(code, "rs");
+        assert!(ret.is_some());
+        let ret_str = ret.unwrap();
+        // Should be "Result<()>", not "bool) -> Result<()>"
+        assert!(
+            ret_str.starts_with("Result"),
+            "Return type should be 'Result<()>', got: '{ret_str}'"
+        );
+    }
+
     // BUG: extract_return_type with multi-line complex types
     #[test]
     fn test_extract_return_type_complex() {

src/core/function_chunker.rs

@@ -815,7 +815,7 @@ fn next_func() {
         );
     }
 
-    // BUG: find_enclosing_function panics on underflow if end_line < start_line
+    // find_enclosing_function: verify no underflow if end_line < start_line
     #[test]
     fn test_find_enclosing_function_bad_boundary() {
         let boundaries = vec![

src/core/multi_pass.rs

@@ -288,7 +288,7 @@ fn analyze_file_risk(diff: &UnifiedDiff) -> HotspotResult {
     let max_line = diff
         .hunks
         .iter()
-        .map(|h| h.new_start + h.new_lines)
+        .map(|h| h.new_start + h.new_lines.saturating_sub(1))
         .max()
         .unwrap_or(1);
 
@@ -701,6 +701,42 @@ mod tests {
         assert!(hotspots[0].risk_score <= 1.0);
     }
 
+    // BUG: max_line uses new_start + new_lines instead of new_start + new_lines - 1
+    // A hunk at line 10 with 3 lines (10,11,12) should give max_line=12, not 13
+    #[test]
+    fn test_hotspot_line_range_end() {
+        let review = MultiPassReview::with_defaults();
+        // Use "auth" path to trigger risk_score > 0.0 so the hotspot isn't filtered
+        let diffs = vec![UnifiedDiff {
+            file_path: PathBuf::from("src/auth.rs"),
+            old_content: None,
+            new_content: None,
+            hunks: vec![crate::core::diff_parser::DiffHunk {
+                old_start: 10,
+                old_lines: 3,
+                new_start: 10,
+                new_lines: 3,
+                context: String::new(),
+                changes: vec![
+                    make_added_line(10, "line 10"),
+                    make_added_line(11, "line 11"),
+                    make_added_line(12, "line 12"),
+                ],
+            }],
+            is_binary: false,
+            is_deleted: false,
+            is_new: false,
+        }];
+        let hotspots = review.detect_hotspots(&diffs);
+        assert_eq!(hotspots.len(), 1);
+        // Lines are 10,11,12 → max should be 12, not 13
+        assert_eq!(
+            hotspots[0].line_range.1, 12,
+            "max_line should be 12 (new_start + new_lines - 1), got {}",
+            hotspots[0].line_range.1
+        );
+    }
+
     #[test]
     fn test_multipass_config_default() {
         let config = MultiPassConfig::default();