Fix recursive function type error with for-in loops (#2216)

[Definisi]

Summary

Fixes #2216 - "Recursive Function Type Error"

This PR fixes the error Type function instance intersect<blocked-XXXXX, ~nil> is uninhabited that occurred when a recursive function used a for-in loop over its own recursive call result.

Problem

The following code would produce a confusing type error:

--!strict
type tb_any = {[any]:any}

function flatten(t: tb_any): tb_any
    local out: tb_any = {}
    for k, v in flatten(t) do
        out[k] = v
    end
    return out
end

Before Fix (Error Output)

Type inference failed to complete, you may see some confusing types and type errors.
Type function instance intersect<blocked-110838, ~nil> is uninhabited
This is likely to be a bug, please report it at https://github.com/luau-lang/luau/issues

After Fix (No Error)

The code type-checks successfully with no errors.

Root Cause

The issue was in ConstraintGenerator::lookup(). When looking up a type for a phi DefId (which represents captured variables across function boundaries):

1. GlobalPrepopulator sets lvalueTypes[phiDef] = BlockedType for all global references during prepopulation
2. When checking a recursive function call inside the function body, the reference gets a capture phi DefId
3. The lookup function first checked if the phi was directly bound in the scope
4. It found the BlockedType from prepopulation and returned it immediately
5. This shadowed the correct function signature that should have been found through the phi's operands

The BlockedType never got resolved because of a dependency cycle, causing the intersect<blocked, ~nil> type function to fail.

Fix

Modified ConstraintGenerator::lookup() to prefer resolving phi types through their operands first (for single-operand phis), before falling back to direct binding lookup:

// For phis with exactly 1 operand, prefer resolving through the operand first.
if (!prototype && phi->operands.size() == 1)
{
    if (auto operandTy = lookup(scope, location, phi->operands.at(0), prototype))
        return operandTy;
}
// Fall back to direct phi lookup
if (auto found = scope->lookup(def))
    return *found;

This ensures that for recursive function references, the lookup correctly resolves through the phi operand (which points to the Cell DefId bound to the function signature) instead of returning the prepopulated BlockedType.

Additional Fixes

• Fixed occurs() in BuiltinTypeFunctions.cpp which was incorrectly checking for UnionType instead of IntersectionType
• Added recursive type detection for the intersect type function to handle degenerate recursive types

Test Plan

• Added test case oss_2216_recursive_function_with_for_in_loop that verifies the exact code pattern from the issue
• All existing tests pass (4470 tests)