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.

examples/probes/pack-expansion-parses.sx

@@ -7,13 +7,13 @@
 // checks are the parser unit tests in src/parser.zig ("parse pack expansion: …").
 
 // 1. Tuple value position — `(..pack)` / `(..pack.field)`:
-tv1 :: () => (..xs);
-tv2 :: () => (..xs.value);
-tv3 :: () => (a, ..xs, b);            // mixed positional + spread
+tv1 :: () => .(..xs);
+tv2 :: () => .(..xs.value);
+tv3 :: () => .(a, ..xs, b);            // mixed positional + spread
 
 // 2. Tuple type position — `(..F(Ts))` / `(..F(Ts.Arg))`:
-tt1 :: (x: (..ValueListenable(Ts)))       => x;
-tt2 :: (x: (..ValueListenable(Ts.Arg)))   => x;
+tt1 :: (x: Tuple(..ValueListenable(Ts)))       => x;
+tt2 :: (x: Tuple(..ValueListenable(Ts.Arg)))   => x;
 
 // 3. Call-arg position — `..pack` / `..pack.field` (reuses spread_expr):
 ca1 :: () => f(..xs);

examples/probes/tuple-baseline.sx

@@ -11,35 +11,35 @@
 #import "modules/std.sx";
 
 Listenable :: struct { value: i64; }      // stand-in element struct
-Combined   :: struct { sources: (i32, i32); }  // tuple-typed field (Decision 2)
+Combined   :: struct { sources: Tuple(i32, i32); }  // tuple-typed field (Decision 2)
 
-swap :: (a: i64, b: i64) -> (i64, i64) { (b, a) }
-fst  :: (t: (i64, i64)) -> i64 { t.0 }
+swap :: (a: i64, b: i64) -> Tuple(i64, i64) { .(b, a) }
+fst  :: (t: Tuple(i64, i64)) -> i64 { t.0 }
 
 main :: () -> i32 {
     // ── Block A — primitives (WORKS) ───────────────────────────────
-    pair := (40, 2);                       // inferred positional
+    pair := .(40, 2);                       // inferred positional
     print("A.idx     {} {}\n", pair.0, pair.1);
-    named := (x: 10, y: 20);               // named + numeric access
+    named := .(x = 10, y = 20);               // named + numeric access
     print("A.named   {} {} {}\n", named.x, named.0, named.1);
-    one := (42,);                          // 1-tuple
+    one := .(42);                          // 1-tuple
     print("A.one     {}\n", one.0);
     a : i64 = pair.0;                      // element into typed local
     print("A.local   {}\n", a);
 
     // ── Block B — storage in a struct field (WORKS; core of Decision 2)
     c : Combined = ---;
-    c.sources = (7, 9);                    // assign tuple value to field
+    c.sources = .(7, 9);                    // assign tuple value to field
     print("B.field   {} {}\n", c.sources.0, c.sources.1);
 
     // ── Block C — return / pass / operators (WORKS) ────────────────
     s := swap(1, 2);
     print("C.ret     {} {}\n", s.0, s.1);
-    print("C.pass    {}\n", fst((11, 22)));
-    print("C.eq      {}\n", (1, 2) == (1, 2));
-    cc := (1, 2) + (3, 4);
+    print("C.pass    {}\n", fst(.(11, 22)));
+    print("C.eq      {}\n", .(1, 2) == .(1, 2));
+    cc := .(1, 2) + .(3, 4);
     print("C.concat  {} {}\n", cc.0, cc.3);
-    print("C.mem     {}\n", 3 in (1, 2, 3));
+    print("C.mem     {}\n", 3 in .(1, 2, 3));
     0
 }