feat(metatype): widen type_info/define to tuple types

TypeInfo gains a `tuple(TupleInfo) variant (TupleInfo{elements: []Type},
positional/unnamed) — completing the reflect/construct triad with enum
and struct.

- meta.sx: TupleInfo + `tuple TypeInfo variant.
- interp: reflectTypeInfo builds .tuple (tag 2) as bare type_tag elements
  (no name pairs); defineType dispatches tag 2 -> defineTuple, which
  decodes []Type and completes the declare slot as a structural .tuple
  via replaceKeyedInfo (kind change). Tuples are structural so the
  declared name is vestigial, but the slot is still completed in place so
  define returns the handle (consistent with enum/struct).
- call.zig: the lower-time type_info guard now admits .tuple.

define(declare("P"), .tuple(.{elements=.[i64,f64]})) builds a tuple, and
define(declare("T"), type_info((i64,bool,f64))) round-trips one. Suite
green (683).

src/ir/interp.zig

@@ -2095,7 +2095,15 @@ pub const Interpreter = struct {
                 }
                 break :blk 1;
             },
-            else => return bailDetail("comptime type_info: only enum / tagged-union / struct types reflect today"),
+            .tuple => |t| blk: {
+                // Tuple elements are POSITIONAL — bare `type_tag` values, not
+                // `{ name, type }` pairs (TupleInfo carries no field names).
+                for (t.fields) |elem_ty| {
+                    elems.append(self.alloc, .{ .type_tag = elem_ty }) catch return error.CannotEvalComptime;
+                }
+                break :blk 2;
+            },
+            else => return bailDetail("comptime type_info: only enum / tagged-union / struct / tuple types reflect today"),
         };
         if (elems.items.len == 0) return bailDetail("comptime type_info: type has no members");
 
@@ -2124,7 +2132,8 @@ pub const Interpreter = struct {
         return switch (tag) {
             0 => self.defineEnum(tbl, handle, info_val),
             1 => self.defineStruct(tbl, handle, info_val),
-            else => bailDetail("comptime define(): unknown TypeInfo variant (only `.enum` / `.struct` are supported)"),
+            2 => self.defineTuple(tbl, handle, info_val),
+            else => bailDetail("comptime define(): unknown TypeInfo variant (only `.enum` / `.struct` / `.tuple` are supported)"),
         };
     }
 
@@ -2249,6 +2258,37 @@ pub const Interpreter = struct {
         tbl.replaceKeyedInfo(handle, full);
         return .{ .value = .{ .type_tag = handle } };
     }
+
+    /// Complete a `declare()`d slot from a `.tuple(TupleInfo)` `TypeInfo` VALUE.
+    /// TupleInfo is `{ elements }`, each element a bare `Type` (positional, no
+    /// name). Tuples are structural, so the declared NAME is vestigial — we still
+    /// complete the slot in place (so `define` returns the handle, like the
+    /// enum/struct paths) via `replaceKeyedInfo` (kind change: tagged_union slot →
+    /// tuple, re-keyed structurally by element types).
+    fn defineTuple(self: *Interpreter, tbl: *types.TypeTable, handle: TypeId, info_val: Value) InterpError!ExecResult {
+        const ti_fields = info_val.aggregate; // defineType already checked the shape
+        const tinfo = ti_fields[1];
+        const tinfo_fields = switch (tinfo) {
+            .aggregate => |f| f,
+            else => return bailDetail("comptime define(): `.tuple` payload is not a TupleInfo struct value"),
+        };
+        if (tinfo_fields.len != 1) return bailDetail("comptime define(): TupleInfo must have an `elements` field");
+        const elems = decodeVariantElements(tinfo_fields[0]) orelse
+            return bailDetail("comptime define(): `elements` is not a slice/array of Type");
+        if (elems.len == 0) return bailDetail("comptime define(): tuple has no elements");
+
+        var field_tys = std.ArrayList(TypeId).empty;
+        for (elems) |elem| {
+            const ety = elem.asTypeId() orelse return bailDetail("comptime define(): tuple element is not a Type value");
+            field_tys.append(self.alloc, ety) catch return error.CannotEvalComptime;
+        }
+
+        const cur = tbl.get(handle);
+        if (cur != .tagged_union) return bailDetail("comptime define(): handle is not a declare()'d slot");
+        const full: types.TypeInfo = .{ .tuple = .{ .fields = field_tys.items, .names = null } };
+        tbl.replaceKeyedInfo(handle, full);
+        return .{ .value = .{ .type_tag = handle } };
+    }
 };
 
 /// Normalize an interpreter value into the list of EnumVariant element values.