lang 2.3: TYPE-position pack projection xs.T (tuple type + closure sig)

`xs.T` projects each pack element's protocol type-arg into a type list, usable
in TYPE/signature positions:
- tuple type `(..xs.T)` → e.g. `(s64, string)` (new resolveTupleTypeWithBindings)
- closure sig `Closure(..xs.T) -> R` → e.g. `Closure(s64, s64) -> s64`, which
  contextually types a closure literal (resolveClosureTypeWithBindings now
  expands a protocol pack via packTypeArgs).

Wired `tuple_type_expr` into `resolveTypeWithBindings` (type_bridge's tuple
resolver is stateless — can't see packs). `packTypeArgs(pack_name, projection)`
is shared: bare `..xs` → element types (`pack_arg_types`); `..xs.T` → each
element's `impl Box(args) for elem` target_arg (`elementProtocolTypeArg` scans
`param_impl_map`). In type position `xs.T` parses as a dotted `type_expr`, so
packTypeElems splits on '.'. examples/199-pack-type-projection.sx.

This completes 2.3's core: all spread/projection forms — call-arg, tuple value,
tuple type, closure sig — now lower. The canonical's `Closure(..sources.T)` /
`mapper(..sources.value)` / `(..sources)` shapes are functional.

examples/199-pack-type-projection.sx

@@ -0,0 +1,38 @@
+// Feature 1 — TYPE-position pack projection `xs.T`. The per-element protocol
+// type-arg `T` projects into a Pack of types, usable in type/signature
+// positions: a tuple type `(..xs.T)` and a closure signature
+// `Closure(..xs.T) -> R`. (`T` of each element comes from its
+// `impl Box(T) for <elem>`.)
+
+#import "modules/std.sx";
+
+Box :: protocol(T: Type) {
+    get :: () -> T;
+}
+
+IntCell :: struct { v: s64; }
+StrCell :: struct { s: string; }
+Dbl :: struct { n: s64; }
+impl Box(s64) for IntCell { get :: (self: *IntCell) -> s64 => self.v; }
+impl Box(string) for StrCell { get :: (self: *StrCell) -> string => self.s; }
+impl Box(s64) for Dbl { get :: (self: *Dbl) -> s64 => self.n * 2; }
+
+// Tuple type `(..xs.T)` — heterogeneous (s64, string), matched by the
+// value-projection `(..xs.get)`.
+snap :: (..xs: Box) -> void {
+    t : (..xs.T) = (..xs.get);
+    print("0={} 1={}\n", t.0, t.1);
+}
+
+// Closure signature `Closure(..xs.T) -> s64` — here `Closure(s64, s64) -> s64`.
+// The closure literal's params are contextually typed from the projection.
+fold :: (..xs: Box) -> s64 {
+    cb : Closure(..xs.T) -> s64 = (a, b) => a + b;
+    return cb(xs[0].get(), xs[1].get());
+}
+
+main :: () -> s32 {
+    snap(IntCell.{ v = 42 }, StrCell.{ s = "hi" });   // (s64, string)
+    print("fold={}\n", fold(IntCell.{ v = 10 }, Dbl.{ n = 5 }));   // 10 + 10 = 20
+    0;
+}