Sema: Fix compilation timeout in analyzeAs with nested cast builtins

Resolves a circular dependency issue where `@as` coercion with nested
cast builtins (`@intCast`, `@floatCast`, `@ptrCast`, `@truncate`) would
cause infinite recursion in complex control flow contexts.

The bug occurs when the pattern `@as(DestType, @intcast(value))` appears
in code with:
- Loop constructs
- Short-circuit boolean operations (OR/AND)
- Optional unwrapping

Example problematic pattern:
```zig
while (condition) {
    if (opt == null or (opt.?)[@as(usize, @intcast(pid))] == false) {
        break;
    }
}
```

Root cause: The original code would resolve the operand before the
destination type, causing the inner cast builtin to recursively analyze
without type context, leading to circular dependencies in the type
resolution system.

Fix: When the operand is a cast builtin, resolve the destination type
FIRST, then analyze the inner cast with proper type context. This breaks
the circular dependency while maintaining correct type coercion semantics.

The fix adds an optimization path that:
1. Detects when operand is a type-directed cast builtin
2. Resolves destination type before analyzing the operand
3. Skips redundant outer coercion if types already match
4. Preserves existing behavior for non-cast operands

Tested with Bun codebase which previously timed out during compilation.
The pattern appears in src/install/updatePackageJSONAndInstall.zig:722.

Related: oven-sh/bun

Author: fmguerreiro

src/Sema.zig

@@ -9651,6 +9651,50 @@ fn analyzeAs(
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
+
+    // Optimize nested cast builtins to prevent redundant coercion and circular dependencies.
+    if (zir_operand.toIndex()) |operand_index| {
+        const operand_tag = sema.code.instructions.items(.tag)[@intFromEnum(operand_index)];
+        switch (operand_tag) {
+            // These builtins perform their own type-directed casting
+            .int_cast, .float_cast, .ptr_cast, .truncate => {
+                // Resolve dest_ty first so inner cast can use it as type context
+                const dest_ty = try sema.resolveTypeOrPoison(block, src, zir_dest_type) orelse {
+                    return sema.resolveInst(zir_operand);
+                };
+
+                // Validate dest_ty (same checks as below)
+                switch (dest_ty.zigTypeTag(zcu)) {
+                    .@"opaque" => return sema.fail(block, src, "cannot cast to opaque type '{f}'", .{dest_ty.fmt(pt)}),
+                    .noreturn => return sema.fail(block, src, "cannot cast to noreturn", .{}),
+                    else => {},
+                }
+
+                // Now analyze inner cast with dest_ty already resolved
+                const operand = try sema.resolveInst(zir_operand);
+
+                // If inner cast already produced the correct type, skip redundant coercion
+                if (sema.typeOf(operand).eql(dest_ty, zcu)) {
+                    return operand;
+                }
+
+                // Otherwise perform outer coercion (handles vectors/arrays and other edge cases)
+                const is_ret = if (zir_dest_type.toIndex()) |ptr_index|
+                    sema.code.instructions.items(.tag)[@intFromEnum(ptr_index)] == .ret_type
+                else
+                    false;
+                return sema.coerceExtra(block, dest_ty, operand, src, .{
+                    .is_ret = is_ret,
+                    .no_cast_to_comptime_int = no_cast_to_comptime_int
+                }) catch |err| switch (err) {
+                    error.NotCoercible => unreachable,
+                    else => |e| return e,
+                };
+            },
+            else => {},
+        }
+    }
+
     const operand = try sema.resolveInst(zir_operand);
     const dest_ty = try sema.resolveTypeOrPoison(block, src, zir_dest_type) orelse return operand;
     switch (dest_ty.zigTypeTag(zcu)) {