fix(flow): defer stacked condition narrowing during flow walks

When `get_type_at_flow()` walked backward through a chain of condition
nodes, each guard tried to resolve its predecessor immediately. That
worked for shallow control flow, but repeated correlated
`@return_overload` guards such as:

- `if not ok then error(result) end`
- `if ok == false then error(result) end`

kept re-entering condition inference for the same sibling return values
before the walk had reached a stable base type. In large enough chains
that caused semantic model construction to recurse until the stack
overflowed.

Restructure condition narrowing so the flow walker stays iterative
across stacked guards.

The new shape is:

- condition handlers return a `ConditionFlowAction`
- a condition can either:
  - produce an immediate narrowed type
  - emit a deferred `PendingConditionNarrow`
  - or continue walking without narrowing
- `get_type_at_flow()` collects pending narrows while it traverses
  antecedents and applies them in reverse order once the underlying
  source type is known

This keeps stacked truthiness, `==` / `~=`, type-guard, and correlated
return-overload narrowing on the main iterative flow walk instead of
resolving each predecessor recursively.

Correlated return-overload narrowing is also split into prepare/apply
phases. `prepare_var_from_return_overload_condition()` now computes a
`CorrelatedConditionNarrowing` description up front, and the final
intersection with the target antecedent type happens later when the
pending narrows are applied. That preserves the existing
correlated-vs-uncorrelated merge behavior without reopening the same
flow question during predecessor traversal.

Add an explicit "ignore condition narrowing" mode for assignment source
lookup. This matters when a variable is reassigned from a fresh
multi-return call after an earlier correlated guard: the assignment
source should be inferred from the underlying flow state, not from stale
pending narrows gathered before the new assignment.

Keep the direct `>` / `>=` narrowing path intact and limit the deferred
prepass to the condition forms that need it, so the change stays focused
on the stacked guard recursion problem.

Author: lewis6991

crates/emmylua_code_analysis/src/compilation/test/return_overload_flow_test.rs

@@ -2,6 +2,8 @@
 mod test {
     use crate::{DiagnosticCode, VirtualWorkspace};
 
+    const STACKED_CORRELATED_GUARDS: usize = 180;
+
     #[test]
     fn test_return_overload_narrow_after_not() {
         let mut ws = VirtualWorkspace::new();
@@ -541,4 +543,168 @@ mod test {
         assert!(after_guard.contains("integer"));
         assert!(!after_guard.contains("string"));
     }
+
+    #[test]
+    fn test_return_overload_stacked_same_discriminant_guards_build_semantic_model() {
+        let mut ws = VirtualWorkspace::new();
+        let repeated_guards =
+            "if not ok then error(result) end\n".repeat(STACKED_CORRELATED_GUARDS);
+        let block = format!(
+            r#"
+            ---@generic T, E
+            ---@param ok boolean
+            ---@param success T
+            ---@param failure E
+            ---@return boolean
+            ---@return T|E
+            ---@return_overload true, T
+            ---@return_overload false, E
+            local function pick(ok, success, failure)
+                if ok then
+                    return true, success
+                end
+                return false, failure
+            end
+
+            local cond ---@type boolean
+            local ok, result = pick(cond, 1, "error")
+
+            {repeated_guards}
+            narrowed = result
+            "#,
+        );
+
+        let file_id = ws.def(&block);
+
+        assert!(
+            ws.analysis
+                .compilation
+                .get_semantic_model(file_id)
+                .is_some(),
+            "expected semantic model for stacked correlated-guard repro"
+        );
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
+    }
+
+    #[test]
+    fn test_return_overload_stacked_eq_guards_build_semantic_model() {
+        let mut ws = VirtualWorkspace::new();
+        let repeated_guards =
+            "if ok == false then error(result) end\n".repeat(STACKED_CORRELATED_GUARDS);
+        let block = format!(
+            r#"
+            ---@generic T, E
+            ---@param ok boolean
+            ---@param success T
+            ---@param failure E
+            ---@return boolean
+            ---@return T|E
+            ---@return_overload true, T
+            ---@return_overload false, E
+            local function pick(ok, success, failure)
+                if ok then
+                    return true, success
+                end
+                return false, failure
+            end
+
+            local cond ---@type boolean
+            local ok, result = pick(cond, 1, "error")
+
+            {repeated_guards}
+            narrowed = result
+            "#,
+        );
+
+        let file_id = ws.def(&block);
+
+        assert!(
+            ws.analysis
+                .compilation
+                .get_semantic_model(file_id)
+                .is_some(),
+            "expected semantic model for stacked correlated-eq repro"
+        );
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
+    }
+
+    #[test]
+    fn test_return_overload_uncorrelated_later_guard_keeps_prior_narrowing() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+            ---@generic T, E
+            ---@param ok boolean
+            ---@param success T
+            ---@param failure E
+            ---@return boolean
+            ---@return T|E
+            ---@return_overload true, T
+            ---@return_overload false, E
+            local function pick(ok, success, failure)
+                if ok then
+                    return true, success
+                end
+                return false, failure
+            end
+
+            local cond ---@type boolean
+            local ok, result = pick(cond, 1, "err")
+
+            if not ok then
+                error(result)
+            end
+
+            ok = cond
+
+            if not ok then
+                error(result)
+            end
+
+            narrowed = result
+            "#,
+        );
+
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
+    }
+
+    #[test]
+    fn test_return_overload_reassign_from_fresh_call_ignores_prior_guard() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+            ---@generic T, E
+            ---@param ok boolean
+            ---@param success T
+            ---@param failure E
+            ---@return boolean
+            ---@return T|E
+            ---@return_overload true, T
+            ---@return_overload false, E
+            local function pick(ok, success, failure)
+                if ok then
+                    return true, success
+                end
+                return false, failure
+            end
+
+            local cond ---@type boolean
+            local branch ---@type boolean
+            local ok, result = pick(cond, 1, "err")
+
+            if not ok then
+                error(result)
+            end
+
+            if branch then
+                ok, result = pick(cond, "x", 2)
+                narrowed = result
+            end
+            "#,
+        );
+
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer|string"));
+    }
 }