ffi M5.A.next.3a.B: $args[$i] in type positions — parser + resolver

Step 3 first slice. `$<pack>[<int_literal>]` now parses in
every type position and resolves against the active pack
binding (`pack_arg_types` map set up by `monomorphizePackFn`).

Plumbing:

- src/ast.zig: new `PackIndexTypeExpr { pack_name, index }`
  AST node + `pack_index_type_expr` variant in `Data`.
- src/parser.zig: in `parseTypeExpr`'s `$<ident>` arm, peek
  for `[`. If found, parse a non-negative `int_literal` index
  followed by `]` and emit a `pack_index_type_expr` node.
  Plain `$T` / `$T/Eq` paths unchanged.
- src/ir/lower.zig::resolveTypeWithBindings: handles
  `pack_index_type_expr` first — looks up the pack name in
  `pack_arg_types`, returns `arg_tys[index]` when in range.
  OOB and "no active pack binding" cases emit focused
  diagnostics at the node span.
- src/ir/type_bridge.zig::resolveAstType: handles the same
  node but falls back to `.s64` with a stderr note — the bare
  type_bridge has no access to lowering state. Pack-aware
  callers route through `resolveTypeWithBindings`.
- src/sema.zig: adds `pack_index_type_expr` to the no-op
  arms in `analyzeNode` and `findNodeAtOffset` so the sema
  pass doesn't reject the new variant.

Tests:

- examples/165-pack-type-position.sx (lock-in from 69dcee8)
  flips from parse error to "42 first". Exercises both a
  return-type position (-> $args[0]) AND a local-var
  annotation (second : $args[1] = args[1]); two
  heterogeneous call shapes confirm distinct monos pick
  distinct concrete types per pack index.
- examples/166-pack-type-position-three.sx — three-element
  pack with $args[2] (third element) as return type. Three
  call shapes: (s64,s64,string), (bool,f64,s64),
  (string,string,bool). Prints "third 99 false".

Out of scope (deferred):
- $args[$i] where $i is a comptime-bound expression (only
  literal int supported in this slice).
- $args[$i] in fn-pointer type LITERALS (works for named
  decls but nested fn type expressions need an audit).
- $args[$i] in struct field types.

206/206 example tests + `zig build test` green.

src/ast.zig

@@ -56,6 +56,7 @@ pub const Node = struct {
         pointer_type_expr: PointerTypeExpr,
         many_pointer_type_expr: ManyPointerTypeExpr,
         optional_type_expr: OptionalTypeExpr,
+        pack_index_type_expr: PackIndexTypeExpr,
         force_unwrap: ForceUnwrap,
         null_coalesce: NullCoalesce,
         deref_expr: DerefExpr,
@@ -364,6 +365,15 @@ pub const TypeExpr = struct {
     protocol_constraints: []const []const u8 = &.{}, // e.g. ["Eq", "Hashable"] for $T/Eq/Hashable
 };
 
+/// `$<pack_name>[<index>]` in type position. Resolves to the i-th
+/// element type of the active pack binding. Step 3 of the variadic
+/// heterogeneous type packs feature — used in trampoline bodies,
+/// generic conversions, struct fields parameterised over the pack.
+pub const PackIndexTypeExpr = struct {
+    pack_name: []const u8,
+    index: u32,
+};
+
 pub const DeferStmt = struct {
     expr: *Node,
 };