feat: tuple syntax cutover — Tuple(...) type + .(...) value

Replace the bare-paren tuple grammar with explicit, position-unambiguous
forms, mirroring how structs work:

  type     `(A, B)`        -> `Tuple(A, B)`          (named keeps `:`)
  value    `(a, b)`        -> `.(a, b)`              (named uses `=`)
  typed    (new)           -> `Tuple(A, B).(a, b)`   (like `Point.{...}`)
  failable `-> (T, !)`     -> `-> T !`
           `-> (T1, T2, !)`-> `-> Tuple(T1, T2) !`   (channel outside Tuple)

Bare `(...)` is now grouping only, everywhere; a comma in bare parens is a
hard error with a migration hint. Grouping, function types `(A, B) -> R`,
param lists, lambdas, and match bindings are unaffected.

`Tuple(...)` is strictly a TYPE in every position (including `size_of` /
`type_info` args); a tuple VALUE comes only from `.(...)` (anonymous) or
`Tuple(...).(...)` (explicitly typed). A bare `Tuple(1, 2)` is a tuple
type with non-type elements -> rejected.

The ~110 tuple-bearing corpus files were migrated with a one-shot
AST-aware migrator (the `sx migrate` tool from the prior commit, removed
here). New examples: 0130 (new syntax), 0131 (typed construction), 1060
(named-tuple failable return). 1116 golden updated for the new hint text.

src/ir/lower/error.zig

@@ -323,12 +323,20 @@ pub fn buildFailableTuple(self: *Lowering, ret_ty: TypeId, value_refs: []const R
 /// dropped) for a multi-value one. Callers must pass a value-carrying
 /// tuple — a pure `-> !`'s success type is `void`, handled separately.
 pub fn failableSuccessType(self: *Lowering, op_ty: TypeId) TypeId {
-    const fields = self.module.types.get(op_ty).tuple.fields;
+    const tup = self.module.types.get(op_ty).tuple;
+    const fields = tup.fields;
     const n_vals = fields.len - 1;
     if (n_vals == 1) return fields[0];
+    // Carry the value-field names through, dropping the trailing error-slot
+    // name, so a named failable tuple `-> Tuple(x: A, y: B) !` yields a value
+    // type `(x: A, y: B)` whose `.x`/`.y` fields stay addressable.
+    const succ_names: ?[]const types.StringId = if (tup.names) |ns|
+        self.alloc.dupe(types.StringId, ns[0..n_vals]) catch unreachable
+    else
+        null;
     return self.module.types.intern(.{ .tuple = .{
         .fields = self.alloc.dupe(TypeId, fields[0..n_vals]) catch unreachable,
-        .names = null,
+        .names = succ_names,
     } });
 }
 

src/ir/lower/expr.zig

@@ -1932,6 +1932,26 @@ pub fn lowerTupleLiteral(self: *Lowering, tl: *const ast.TupleLiteral) Ref {
         if (elem.value.data == .spread_expr) has_spread = true;
     }
 
+    // Explicitly-typed construction `Tuple(A, B).( ... )`: the literal carries
+    // its tuple type, exactly like `Name.{ ... }` for structs. Resolve it and
+    // drive element lowering through it as the target tuple — the produced
+    // value equals what the anonymous `.( ... )` form yields against that type.
+    // An ambient contextual `target_type` (annotation / call slot), if present
+    // and a tuple, is honored over the explicit one only when the explicit type
+    // fails to resolve; otherwise the explicit type wins.
+    const saved_explicit_target = self.target_type;
+    var restore_explicit_target = false;
+    if (tl.type_expr) |te| {
+        const tuple_ty = self.resolveTypeWithBindings(te);
+        if (tuple_ty != .unresolved) {
+            self.target_type = tuple_ty;
+            restore_explicit_target = true;
+        }
+    }
+    defer if (restore_explicit_target) {
+        self.target_type = saved_explicit_target;
+    };
+
     // Contextual target tuple field types. Without a spread we require
     // exact arity (existing behavior); with a spread we index positionally
     // by output position (so `(..sources)` into a `(VL(T0), …)` field coerces
@@ -2771,10 +2791,14 @@ pub fn lowerExpr(self: *Lowering, node: *const Node) Ref {
         .optional_type_expr,
         .array_type_expr,
         .function_type_expr,
+        .tuple_type_expr,
         => blk: {
             const ty = self.resolveTypeWithBindings(node);
             // The resolver diagnosed any unresolved leaf; don't mint a Type
-            // value around the failure sentinel.
+            // value around the failure sentinel. For `Tuple(...)` this is also
+            // where a standalone `Tuple(1, 2)` value-expression is rejected —
+            // `resolveTupleTypeWithBindings` diagnoses the non-type element and
+            // returns `.unresolved`, so no value is fabricated.
             if (ty == .unresolved) break :blk self.emitError("unknown_expr", node.span);
             break :blk self.builder.constType(ty);
         },

src/ir/lower/generic.zig

@@ -288,6 +288,7 @@ pub fn isStaticTypeArg(self: *Lowering, node: *const Node) bool {
         .optional_type_expr,
         .function_type_expr,
         .tuple_literal,
+        .tuple_type_expr,
         .call,
         => return true,
         else => return false,
@@ -355,7 +356,7 @@ pub fn resolveTupleLiteralTypeArg(self: *Lowering, node: *const Node) TypeId {
     for (node.data.tuple_literal.elements) |el| {
         if (!type_bridge.isTypeShapedAstNode(el.value, &self.module.types)) {
             if (self.diagnostics) |diags| {
-                diags.addFmt(.err, el.value.span, "tuple type element is not a type (found `{s}`); a tuple used as a type must list only types, e.g. `(i32, i32)`", .{@tagName(el.value.data)});
+                diags.addFmt(.err, el.value.span, "tuple type element is not a type (found `{s}`); a tuple used as a type must list only types, e.g. `Tuple(i32, i32)`", .{@tagName(el.value.data)});
             }
             return .unresolved;
         }
@@ -468,6 +469,7 @@ pub fn resolveTypeArg(self: *Lowering, node: *const Node) TypeId {
         // `(COnly, i64)`) is rejected exactly as in a normal annotation, instead
         // of `type_bridge.resolveAstType`'s ungated global lookup (E4).
         .tuple_literal,
+        .tuple_type_expr,
         .pointer_type_expr,
         .many_pointer_type_expr,
         .array_type_expr,