fix(semantic): make dependent queries safe to re-enter

[lewis6991]

Dependent semantic queries can revisit unfinished work. A provisional
fallback can then be cached as a final answer, which makes later queries
depend on evaluation order. Recursive expression and type evaluation can
also overflow the native stack.

Query caching

Publish in-progress entries before calling dependencies and release
cache borrows before those calls. Track results that read unfinished
work as provisional. Reuse them within the outer query, then discard
them so a later query can retry. Publish dependent cache entries only
when their inputs are complete. Preserve the existing seeds for
recursive inference.

Type evaluation

Use a work list for alias instantiation and conditional continuations.
Share the active alias path across nested semantic queries, and release
it before independent branches. Resolve outer type computations while
keeping fields and array elements lazy. Substitute member arguments at
lookup, then evaluate the result where it is consumed. This supports
recursive data types without unfolding their complete structure.

Use work lists for long flow-expression chains, alias index keys, and
operator forwarding. Share type reconstruction and named substitution
between evaluation, generic result cleanup, and rendering.

Type comparison

Replace the recursive depth guard with a dependency graph and work
queue. Keep matches, mismatches, and unresolved comparisons distinct.
Recheck parents when a dependency changes. Accept a recursive assumption
only when the cycle passes through data constructors, then finish
dependent checks before publishing the result. Alias forwarding alone is
no proof.

A complete union alternative can prove a match despite an unresolved
alternative. A definite mismatch can reject a required set of checks
despite another unfinished check. Keep conditional types deferred when
neither outcome is proven, including during conditional inference.

Resource exhaustion

Exact cycle checks cannot stop computations whose arguments keep
growing:

---@alias Input<T> Filter<Input<T[]>>
---@alias Filter<T> T extends string and T or T[]

Share a work budget across alias evaluation and type comparison. Retain
a stack guard for nested semantic calls that still use native recursion.
Report exhaustion with a type-complexity diagnostic instead of treating
it as a type mismatch. Keep unrelated queries and diagnostics available.

Coverage

Cover recursive JSON types, structural cycles with mismatched fields,
shrinking and finitely changing arguments, growing computations, query
order, and independent branches. Check long valid alias, expression, and
comparison chains, plus deferred conditionals and unrelated diagnostics.

[xuhuanzy]

We should also change SemanticLocalCache into a cache shared within a single request. The key is to prevent model_for from creating an empty cache.

crates\emmylua_code_analysis\src\semantic_model\access.rs pub fn model_for(&self, file_id: FileId) -> Self