lang: tuple element assignment + named-tuple field names

Two fixes:
- Element assignment `t.0 = v` (the known Phase-4.2 gap): the lvalue path
  looked the element up by NAME via getStructFields, never matched a tuple
  (positional), and left field_ty .unresolved -> ptr(.unresolved) -> codegen
  panic. Added a tuple branch to the field-assignment lowering that indexes by
  position (numeric) or name (tup.names), mirroring the read path. Fixes
  `c.sources.0 = v` on a generic-instance pack field too.
- Named tuples: the parser dropped captured field names for a tuple TYPE
  `(x: T, y: U)` (passed field_names=null), and resolveTupleTypeWithBindings
  also nulled them. Both now preserve names (synthesizing _<i> for any unnamed
  slot), so `t.x` reads/writes by name and `.0` by position.

examples/208. 243 examples + unit green.

examples/208-tuple-element-assign.sx

@@ -0,0 +1,25 @@
+// Tuple element assignment + named tuples.
+//   - `t.0 = v` writes one element in place (was a known gap: the lvalue path
+//     looked the element up by name via getStructFields and left the pointee
+//     `.unresolved`; now it indexes the tuple positionally like the read path).
+//   - Named tuples `(x: T, y: U)` keep their field names through parsing and
+//     type resolution, so `t.x` reads/writes by name (and `.0` by position).
+
+#import "modules/std.sx";
+
+main :: () -> s32 {
+    // Positional element assignment.
+    a : (s32, string) = ---;
+    a.0 = 11;
+    a.1 = "x";
+    print("a: {} {}\n", a.0, a.1);
+
+    // Named tuple: write + read by name, and read by position.
+    p : (x: s32, y: string) = ---;
+    p.x = 22;
+    p.y = "y";
+    print("p: x={} y={} .0={}\n", p.x, p.y, p.0);
+    p.0 = 33;                       // position write reaches the same slot as .x
+    print("p.x after .0=33: {}\n", p.x);
+    0;
+}