test: migrate examples to XXXX-category-name layout + split expected streams

Rename all example tests/companions to the XXXX-category-test-name scheme
(per-category 100-blocks: basic 0010, types 0100, ... errors 1000,
diagnostics 1100, ffi 1200, ffi-objc 1300, ffi-jni 1400, vectors 1500,
platform 1600). Companions and dir/C fixtures move in lockstep with their
parent test; #import/#source/#include paths rewritten to match.

Expected output now lives in examples/expected/ (a sibling dir of the
tests) split into three streams per the new convention:
  <name>.exit / <name>.stdout / <name>.stderr  (+ optional <name>.ir)

run_examples.sh rewritten: scans examples/ and issues/ for an
expected/<name>.exit marker, captures stdout and stderr separately (no
more 2>&1), compares each stream + exit + optional IR snapshot.

Behavior validated unchanged: every renamed test reproduces its prior
merged output + exit (diffs limited to file paths/basenames embedded in
diagnostics + traces, which correctly reflect the new names). Suite:
292 passed, 0 failed. 50-smoke.sx split + issue relocation + docs follow
in subsequent commits.

examples/1012-errors-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;
+}