lang: xx <pack> materializes a comptime pack into a runtime slice (issue 0053)

xx args with a slice target now bridges a comptime pack to a runtime slice:
[]Any boxes each element to Any; []P xx-erases each to the protocol (reusing
the slice-of-protocol erasure from 0052). New lowerPackToSlice; the unary-op
arm intercepts xx <pack> before the pack-as-value diagnostic. This is the
working forward to a runtime []Any/[]P helper -- log_count(xx args) -> 3 --
so the 2.7 pack-as-value diagnostics now suggest xx <name> for the call case.

examples/204-pack-xx-to-slice.sx (both []Any and []P paths); 203 help text
updated. issue 0053 FIXED. 239 examples + unit green.

issues/0053-comptime-pack-spread-into-any-slice.md

@@ -1,3 +1,11 @@
+**FIXED** via the `xx <pack>` bridge (the preferred fix below), not by changing
+the `..args` spread. `xx args` with a slice target now materializes the pack
+into a runtime `[]Any`/`[]P` — see [examples/204-pack-xx-to-slice.sx](../examples/204-pack-xx-to-slice.sx).
+`lowerXX`/the unary-op arm intercepts `xx <pack>` before the pack-as-value
+check and calls the new `lowerPackToSlice` ([src/ir/lower.zig](../src/ir/lower.zig)).
+The bare `..args` spread into a non-variadic `[]Any` param is still unsupported
+(use `xx args`); left as-is.
+
 # Symptom
 
 Spreading a comptime pack `..$args` into a `[]Any` parameter — `f(..args)` where
@@ -23,28 +31,43 @@ main :: () -> s32 { print("{}\n", forward(1, "hi", 2.5)); return 0; }
 Expected: `3` (the pack spreads into the `[]Any` slice, like calling
 `log_count(1, "hi", 2.5)` against a `[]Any` variadic would).
 
-# Workaround / current advice
+# Preferred fix — `xx args` (pack → slice materialization)
+
+Rather than make the splat-y `..args` spread collapse into a single slice arg,
+the cleaner spelling is an **`xx` cast**, which already means "erase/convert to
+the expected type":
+
+```sx
+forward :: (..$args) -> s64 { return log_count(xx args); }   // target: []Any
+```
+
+`xx args` (target-typed) should materialize the pack into the expected slice:
+- target `[]Any`  → box each pack element to `Any`, build `[N]Any` → `[]Any`;
+- target `[]P`    → `xx`-erase each element to the protocol `P`, build `[N]P`
+  → `[]P` (reuse the slice-of-protocol erasure landed in `packVariadicCallArgs`,
+  issue 0052).
+
+This reuses the existing `xx`/protocol machinery, reads naturally, and keeps
+`..xs` reserved for true spreads into pack/variadic callees.
+
+**Currently `xx args` errors** ("pack 'args' has no runtime value") because the
+Step 2.7 pack-as-value check fires on the bare `args` operand before `xx` is
+considered. The fix: in `xx` (unary_op `.xx`) lowering, intercept a pack operand
+*before* the pack-as-value diagnostic and, when the target type is a slice,
+materialize as above.
+
+# Workaround today
 
 Declare the forwarder as the **slice** variadic instead of a pack — then it's
-already a runtime `[]Any` and forwards directly (no spread needed):
+already a runtime `[]Any` and forwards directly:
 
 ```sx
 forward :: (..args: []Any) -> s64 { return log_count(args); }   // works -> 3
 ```
 
-This is what `examples/162-pack-bare-args.sx` now demonstrates, and what the
-Step 2.7 pack-as-value diagnostic recommends (declare `..xs: []P` for runtime
-use rather than spreading a pack).
-
-# Suspected area
-
-The call-arg spread lowering (`packSpreadRefs` / `lowerVariadicArgs` /
-`packVariadicCallArgs` interaction in [src/ir/lower.zig](../src/ir/lower.zig)):
-when the spread source is a comptime pack and the callee parameter is a single
-`[]Any` (not itself variadic/pack), the spread must **collect** the pack
-elements into one `[]Any` slice arg, not splat them as separate positional args.
-Compare the working path where the callee is itself a `[]Any` variadic.
+This is what `examples/162-pack-bare-args.sx` demonstrates.
 
 # Verification
 
-The reproduction above should print `3` and pass `sx ir` LLVM verification.
+After the fix, `log_count(xx args)` (and the original `..args` form, if also
+fixed) should print `3` and pass `sx ir` LLVM verification.