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/errors/1036-errors-failable-smoke.sx

@@ -9,7 +9,7 @@
 SmokeErr :: error { Empty, BadDigit, Overflow }
 
 // value-carrying, named set
-sm_parse :: (n: i32) -> (i32, !SmokeErr) {
+sm_parse :: (n: i32) -> i32 !SmokeErr {
     if n < 0  { raise error.BadDigit; }
     if n == 0 { raise error.Empty; }
     if n > 99 { raise error.Overflow; }
@@ -23,10 +23,10 @@ sm_check :: (ok: bool) -> ! {
 }
 
 // multi-value, inferred set: `try` propagates; SCC absorbs SmokeErr
-sm_pair :: (a: i32, b: i32) -> (i32, i32, !) {
+sm_pair :: (a: i32, b: i32) -> Tuple(i32, i32) ! {
     x := try sm_parse(a);
     y := try sm_parse(b);
-    return (x, y);
+    return .(x, y);
 }
 
 // catch with a diverging block body
@@ -38,7 +38,7 @@ sm_or_default :: (n: i32) -> i32 {
 }
 
 // onfail + defer interleave: cleanup runs only on the error path
-sm_acquire :: (fail: bool) -> (i32, !) {
+sm_acquire :: (fail: bool) -> i32 ! {
     defer  print("  defer A\n");
     onfail print("  onfail B\n");
     if fail { raise error.Acquire; }
@@ -46,7 +46,7 @@ sm_acquire :: (fail: bool) -> (i32, !) {
 }
 
 // or-chain: try a, fall to try b; propagate if both fail
-sm_first :: (a: i32, b: i32) -> (i32, !) {
+sm_first :: (a: i32, b: i32) -> i32 ! {
     v := try sm_parse(a) or try sm_parse(b);
     return v;
 }
@@ -54,18 +54,18 @@ sm_first :: (a: i32, b: i32) -> (i32, !) {
 // --- Composition (ERR E5.1): failable closures, widening, generics ---
 
 // Closure(...) param, try-propagated (the env is carried)
-sm_run :: (cb: Closure(i32) -> (i32, !SmokeErr), n: i32) -> (i32, !SmokeErr) {
+sm_run :: (cb: Closure(i32) -> i32 !SmokeErr, n: i32) -> i32 !SmokeErr {
     return try cb(n);
 }
 
 // bare fn-type param: a NON-failable closure literal widens into the failable
 // slot (the ∅-widening adapter wraps `{value, 0}`)
-sm_widen :: (cb: (i32) -> (i32, !SmokeErr), n: i32) -> i32 {
+sm_widen :: (cb: (i32) -> i32 !SmokeErr, n: i32) -> i32 {
     return cb(n) catch (e) -1;
 }
 
 // generic ($T) value-carrying failable composition, monomorphized per call
-sm_wrap :: ($T: Type, f: Closure() -> (T, !SmokeErr)) -> (T, !SmokeErr) {
+sm_wrap :: ($T: Type, f: Closure() -> T !SmokeErr) -> T !SmokeErr {
     return try f();
 }
 
@@ -105,9 +105,9 @@ main :: () {
     if !gerr { print("or-chain: {}\n", g); }
 
     // multi-value failable consumed by catch (tuple body)
-    p, q := sm_pair(0, 3) catch (e) (0, 0);
+    p, q := sm_pair(0, 3) catch (e) .(0, 0);
     print("pair-catch: {} {}\n", p, q);
-    p2, q2 := sm_pair(4, 5) catch (e) (0, 0);
+    p2, q2 := sm_pair(4, 5) catch (e) .(0, 0);
     print("pair-ok: {} {}\n", p2, q2);
 
     // pure failable: absorb with no-binding catch
@@ -120,15 +120,15 @@ main :: () {
     iv, ierr := sm_acquire(false);
 
     // composition: inline failable closure literal through a Closure(...) param
-    cl := sm_run(closure((x: i32) -> (i32, !SmokeErr) { if x < 0 { raise error.BadDigit; } return x * 2; }), 6) catch (e) -1;
+    cl := sm_run(closure((x: i32) -> i32 !SmokeErr { if x < 0 { raise error.BadDigit; } return x * 2; }), 6) catch (e) -1;
     print("closure-run: {}\n", cl);                                                     // 12
-    print("closure-run-err: {}\n", sm_run(closure((x: i32) -> (i32, !SmokeErr) { raise error.Empty; }), 1) catch (e) -9); // -9
+    print("closure-run-err: {}\n", sm_run(closure((x: i32) -> i32 !SmokeErr { raise error.Empty; }), 1) catch (e) -9); // -9
 
     // non-failable closure literal widened into the failable bare slot
     print("widen: {}\n", sm_widen(closure((x: i32) -> i32 => x + 1), 9));               // 10
 
     // generic failable composition (monomorphized at i32)
-    print("wrap: {}\n", sm_wrap(i32, closure(() -> (i32, !SmokeErr) { return 42; })) catch (e) 0); // 42
+    print("wrap: {}\n", sm_wrap(i32, closure(() -> i32 !SmokeErr { return 42; })) catch (e) 0); // 42
 
     print("errors ok\n");
 }