ERR/E2.1b: value-carrying failable consumers (try / catch)

The consumer side of the error-channel tuple ABI. A value-carrying `-> (T, !E)`
failable can now be consumed by `try` and `catch` (not just destructured).
Single-value; multi-value `-> (T1, T2, !)` consumers bail (E2).

- lowerTry: a value-carrying callee returns `{v, err}`. Extract `err`
  (tuple_get field 1), branch; on success the try value is `tuple_get(field 0)`,
  on error propagate via emitErrorReturn (pure caller → `ret(tag)`;
  value-carrying caller → `ret {undef..., tag}`). Widening now runs for
  value-carrying callees too. Retires the two value-carrying bails.
- lowerCatch: a value-carrying LHS merges through a block-param phi — the
  success edge feeds `tuple_get(field 0)`, the handler edge feeds the body's
  value (coerced to the success type). runCatchBody factors the bound-tag body
  lowering (force_block_value for the value case). Pure-failable catch
  unchanged.
- A non-diverging value-carrying catch body that yields no value is now a
  clean diagnostic ("`catch` body must produce a value … or diverge") instead
  of coercing `void` into a bad ref / failing LLVM verification — caught by an
  adversarial review of the lowering.

Tests: examples/229-value-failable-consume.sx (try in value-carrying + pure
callers, catch block/bare/match-body/diverging bodies; exit 32),
examples/230-value-failable-reject.sx (void catch body rejected; exit 1).
Gates: zig build, zig build test, 268/268 examples.

examples/229-value-failable-consume.sx

@@ -0,0 +1,61 @@
+// Consuming value-carrying failables with `try` and `catch` (ERR step E2.1b —
+// the consumer side of the error-channel tuple ABI). `try f()` on a
+// `-> (T, !E)` callee binds the value slot on success and propagates the error
+// on failure (a pure-failable caller returns the tag; a value-carrying caller
+// returns `{undef, tag}`). `f() catch e BODY` yields the value slot on success
+// or the handler body's value on failure, merged through a block parameter.
+// The producer side is `examples/228-value-failable.sx`.
+
+#import "modules/std.sx";
+
+E :: error { Bad, Empty }
+
+parse :: (n: s32) -> (s32, !E) {
+    if n < 0  { raise error.Bad; }
+    if n == 0 { raise error.Empty; }
+    return n * 2;
+}
+
+// value-carrying `try` in a value-carrying caller — propagates {undef, tag}.
+inc :: (n: s32) -> (s32, !E) {
+    v := try parse(n);
+    return v + 1;
+}
+
+// value-carrying `try` in a pure-failable caller — propagates the tag.
+relay :: (n: s32) -> !E {
+    v := try parse(n);
+    if v < 0 { raise error.Bad; }
+    return;
+}
+
+// value-carrying `catch`, bare-expression fallback.
+safe :: (n: s32) -> s32 {
+    return parse(n) catch e 0;
+}
+
+// value-carrying `catch`, match-body value.
+classify :: (n: s32) -> s32 {
+    return parse(n) catch e == {
+        case .Bad:   1;
+        case .Empty: 2;
+        else:        3;
+    };
+}
+
+main :: () -> s32 {
+    r : s32 = 0;
+    a, ea := inc(5);                      // parse(5)=10 → v=10 → 11
+    if ea == error.Bad { r = r + 100; }   // false
+    r = r + a;                             // +11
+    b, eb := inc(-1);                      // parse(-1)=Bad → propagate {undef, Bad}
+    if eb == error.Bad { r = r + 4; }      // true → +4
+    er := relay(3);                        // parse(3)=6 ok → relay ok
+    if er == error.Bad { r = r + 50; }     // false
+    r = r + safe(7);                       // parse(7)=14 → +14
+    r = r + safe(-1);                      // Bad → catch → 0
+    r = r + classify(-1);                  // Bad → 1
+    r = r + classify(0);                   // Empty → 2
+    print("consume result: {}\n", r);      // 11+4+14+0+1+2 = 32
+    return r;
+}

examples/230-value-failable-reject.sx

@@ -0,0 +1,19 @@
+// Value-carrying `catch` rejection (ERR step E2.1b): when the failable LHS
+// carries a value, a non-diverging catch handler must produce a value of the
+// success type — a value-less (void) body is a type error (otherwise the
+// success and error paths couldn't merge to one value). Diverge instead
+// (`return` / `raise`) or yield a value. Positives: `examples/229-value-failable-consume.sx`.
+
+#import "modules/std.sx";
+
+E :: error { Bad }
+
+parse :: (n: s32) -> (s32, !E) {
+    if n < 0 { raise error.Bad; }
+    return n;
+}
+
+main :: () -> s32 {
+    x := parse(-1) catch e { print("oops\n"); };   // error: body yields no value
+    return x;
+}