feat: make_variant — construct a minted tagged-union value by index (stdlib)

The metatype system can MINT tagged-union types (`make_enum`) and READ them
(`field_count`/`field_name`/`field_type`/`field_value`); `make_variant` is the
missing WRITE side — build a value of a minted tagged-union `E` whose active
variant is `idx`, carrying `payload`. Needed when the variant is selected at
RUNTIME but the union was synthesized at comptime so its labels can't be spelled
as a literal `.label(payload)` — e.g. the `race` result: an `inline for 0..N (i)`
arm constructs the i-th variant of a synthesized result with the winner's value.

Pure sx in modules/std/meta.sx (NOT a compiler builtin): a minted tagged-union is
laid out `{ i64 tag @0, payload @ size_of(i64) }` (the compiler fixes `tag_type`
to i64 for minted enums), so make_variant zeroes the value then writes the tag and
payload at those offsets — the same offsets the compiler's own enum_init/payload
ops use. The header comment documents the minted-only / i64-tag layout coupling.

Adversarially reviewed (SHIP): the offset-8 payload assumption is exactly the
compiler's enum layout with no alignment hazard (the payload is an alignment-1
`[N x i8]` array immediately after the i64 header); complex payloads (multi-field
struct, string fat pointer, 40-byte struct) round-trip. Locked by
examples/comptime/0650-comptime-make-variant.sx (heterogeneous + complex payloads,
runtime-index selection via the comptime `case` form). Suite green (822/0).

examples/comptime/0650-comptime-make-variant.sx

@@ -0,0 +1,63 @@
+// `make_variant($E, idx, payload)` (modules/std/meta.sx) — the WRITE side of the
+// metatype reflection triad: construct a value of a MINTED tagged-union by
+// VARIANT INDEX, when the variant is chosen at runtime and the union was
+// synthesized at comptime (so its labels can't be a literal `.label(…)`). This
+// is the shape the `race` result uses: an `inline for 0..N (i)` arm builds the
+// i-th variant of a synthesized result carrying the winner's value.
+//
+// Covers heterogeneous + COMPLEX payloads (multi-field struct, string fat
+// pointer, a larger struct, scalar) — make_variant zeroes the value then writes
+// the i64 tag @0 and the payload @ size_of(i64), so payloads of any size/shape
+// round-trip. Built with the natural early-return-per-arm pattern (a `return`
+// inside an `inline if` inside an `inline for`).
+#import "modules/std.sx";
+#import "modules/std/meta.sx";
+
+Vec3 :: struct { x: f64; y: f64; z: f64; }                    // 24 bytes
+Big  :: struct { a: i64; b: i64; c: i64; d: i64; tag: bool; } // 40 bytes (largest payload)
+
+// A synthesized 4-variant tagged-union with complex, differently-sized payloads.
+R :: make_enum("R", .[
+    EnumVariant.{ name = "v",   payload = Vec3   },
+    EnumVariant.{ name = "s",   payload = string },
+    EnumVariant.{ name = "big", payload = Big    },
+    EnumVariant.{ name = "n",   payload = i64    },
+]);
+
+// Build the variant chosen by a RUNTIME index, in the matching unrolled arm —
+// each arm's payload type differs. The `return` inside the `inline if` inside the
+// `inline for` is the pattern make_variant exists to enable.
+pick :: (idx: i64, vv: Vec3, sv: string, bv: Big, nv: i64) -> R {
+    inline for 0..field_count(R) (i) {
+        if idx == i {
+            // Comptime match on the loop cursor `i` selects the arm whose payload
+            // type matches variant `i` — cleaner than nested `inline if`/`else`.
+            inline if i == {
+                case 0: { return make_variant(R, i, vv); }
+                case 1: { return make_variant(R, i, sv); }
+                case 2: { return make_variant(R, i, bv); }
+                else:   { return make_variant(R, i, nv); }
+            }
+        }
+    }
+    return make_variant(R, 3, -1);   // unreachable for a valid idx
+}
+
+show :: (r: R) {
+    if r == {
+        case .v:   (p) { print("v = {} {} {}\n", p.x, p.y, p.z); }
+        case .s:   (p) { print("s = {}\n", p); }
+        case .big: (p) { print("big = {} {} {} {} {}\n", p.a, p.b, p.c, p.d, p.tag); }
+        case .n:   (p) { print("n = {}\n", p); }
+    }
+}
+
+main :: () -> i32 {
+    v :: Vec3.{ x = 1.5, y = 2.5, z = 3.5 };
+    b :: Big.{ a = 10, b = 20, c = 30, d = 40, tag = true };
+    show(pick(0, v, "hello", b, 99));
+    show(pick(1, v, "hello", b, 99));
+    show(pick(2, v, "hello", b, 99));
+    show(pick(3, v, "hello", b, 99));
+    return 0;
+}