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/parser.zig

@@ -460,7 +460,10 @@ pub const Parser = struct {
             return try self.createNode(start, .{ .array_type_expr = .{ .length = len_node, .element_type = elem_type } });
         }
 
-        // Generic type parameter introduction: $T or $T/Protocol1/Protocol2
+        // Generic type parameter introduction: $T or $T/Protocol1/Protocol2.
+        // Also: pack-index type access $args[<int_literal>] — resolves to
+        // the i-th element type of the active pack binding (step 3 of
+        // the variadic heterogeneous type packs feature).
         if (self.current.tag == .dollar) {
             self.advance();
             if (self.current.tag != .identifier) {
@@ -468,6 +471,24 @@ pub const Parser = struct {
             }
             const name = self.tokenSlice(self.current);
             self.advance();
+            // Pack-index access: $<pack_name>[<int_literal>]
+            if (self.current.tag == .l_bracket) {
+                self.advance(); // skip '['
+                if (self.current.tag != .int_literal) {
+                    return self.fail("expected integer literal in pack index");
+                }
+                const idx_text = self.tokenSlice(self.current);
+                const idx_val = std.fmt.parseInt(i64, idx_text, 10) catch {
+                    return self.fail("invalid integer literal in pack index");
+                };
+                if (idx_val < 0) return self.fail("pack index cannot be negative");
+                self.advance();
+                try self.expect(.r_bracket);
+                return try self.createNode(start, .{ .pack_index_type_expr = .{
+                    .pack_name = name,
+                    .index = @intCast(idx_val),
+                } });
+            }
             // Parse optional protocol constraints: $T/Eq/Hashable
             var constraints = std.ArrayList([]const u8).empty;
             while (self.current.tag == .slash) {