fix(flow): apply deferred narrows after antecedent resolution

When walking backward through flow, collect condition narrows as pending
actions instead of applying them while recursively querying antecedent
types. The eager path mixed narrowing with antecedent resolution, so
stacked guards could re-enter flow inference from inside condition
evaluation and build deep recursive chains across repeated truthiness,
type-guard, signature-cast, and correlated return-overload checks.

Resolve the antecedent type first, then apply the pending narrows in
reverse order. That keeps narrowing as a post-pass over an
already-resolved input, avoids re-entering the same condition chain
while answering the current flow query, and lets same-variable
self/member guards wait until earlier guards have narrowed the receiver
enough for reliable lookup.

Key the flow cache by whether condition narrowing is enabled, and
separate assignment source lookup from condition application. Reuse a
narrowed source only when the RHS preserves that precision; broader RHS
expressions fall back to the antecedent type with condition narrowing
disabled so reassignment clears stale branch narrows, while exact
literals and compatible partial table/object rewrites still preserve
useful narrowing.

Add regression coverage for stacked guards, correlated overload joins,
pcall aliases, and assign/return diagnostics.

Author: lewis6991

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

@@ -2,6 +2,8 @@
 mod test {
     use crate::{DiagnosticCode, VirtualWorkspace};
 
+    const STACKED_PCALL_ALIAS_GUARDS: usize = 180;
+
     #[test]
     fn test_issue_263() {
         let mut ws = VirtualWorkspace::new_with_init_std_lib();
@@ -141,4 +143,36 @@ mod test {
         assert_eq!(ws.expr_ty("status"), ws.ty("boolean|string"));
         assert_eq!(ws.expr_ty("payload"), ws.ty("integer|string"));
     }
+
+    #[test]
+    fn test_pcall_stacked_alias_guards_build_semantic_model() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+        let repeated_guards =
+            "if failed then error(result) end\n".repeat(STACKED_PCALL_ALIAS_GUARDS);
+        let block = format!(
+            r#"
+        ---@return integer
+        local function foo()
+            return 1
+        end
+
+        local ok, result = pcall(foo)
+        local failed = ok == false
+
+        {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 pcall alias guard repro"
+        );
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
+    }
 }