[lewis6991]

Signature help can show old overloads after a function is replaced by an assignment or a cast. This change keeps only the original signatures that can still apply at the call.

Two functions can have the same main signature and different overloads. The analyzer must track which function is used, even when its type stays the same:

---@param value number
---@overload fun(value: string): string
local function accept(value) return value end

---@param value number
local function replacement(value) return value end

accept = (accept) -- Keep the string overload.
accept = replacement -- Remove the string overload.

Reuse the existing code that follows assignments, casts and branches. Add a mode that keeps only the original signatures that still apply. Self-assignment keeps them. Other assignments and replacement casts remove them. Removal casts remove only matching signatures. Combine signatures from branches that can run.

The shared flow code needs these changes:

• Use one work stack for pending assignments, casts and branches. Long branch chains can then reuse shared earlier results without deeply nested Rust calls. Keep the existing assignment type checks in one helper.
• Save intermediate results so repeated calls can reuse earlier work. Keep later casts out of earlier saved results. Keep results separate for each mode, original function and full signature list, including generic type arguments.
• Check current, fully known return types before using a function call to rule out a branch. The function must be local, have no replacement assignments and have no declared overloads. A generic return that can still be false or nil cannot provide this proof. Save the check of the function's assignments so each condition does not scan them again.

Keep the existing generic type information and the main signature from each branch where the original function still applies. Normal type inference keeps its current function type information.

This shared support also lets later annotation and pcall checks use the same assignment and branch rules. A separate signature tracker would need another copy of those rules and another cache. Annotation priority, argument checks through pcall, and wider changes to function-call inference remain separate work.