test: migrate global value r/w family-5 to test/lang @test, retire C twins (fold-2)

Continue fold-2: migrate the global-value read/store/addr-of family (non-tagged)
from bespoke build+run C twins to test/lang @test, retiring each twin in the
same commit. Runtime coverage MOVES from $(TESTS) to test-lang (T1 runs+asserts
via `ww test`) + test-lang-byteid (T2 keeps cs==ww .s byte-id); the $(TESTS)
headline drops 3 (421->418). All asserts are primitive int comparisons; fresh
globals are zeroed, so a store that misses the symbol reads back 0 and FAILS.

  989_globptrfield_run.c  -> glob_ptr_field_test.ww  (scalar field store through a module-global *struct pointer loads the pointer from gp(SB), not saved BP; runtime gp=&backing form, static-init is #48-blocked)
  989_globstructret_run.c -> glob_struct_ret_test.ww (returning a module-global struct ident by value copies g's bytes; rsz 16 + rsz 24, each field asserted)
  989_dotbasehijack_run.c -> dotbase_hijack_test.ww  (indexing an [N]T field of a module-global struct addresses the struct field, not an unrelated global sharing the field name; +typed-inner control +colliding-global-intact pin)

glob_ptr_field keeps only the .c's offset-0 row: an added non-zero-offset row
(gp.g=9) surfaced a cs!=ww divergence (cstage folds the offset into the store
displacement `MOVQ AX,8(BX)`; wwstage emits `ADDQ $8,BX; MOVQ AX,(BX)`) — a
latent global-*struct-pointer field-store divergence beyond the .c's coverage,
reported for the backlog, not carried here. Bump LANGBYTEID_EXPECTED_MIN 35->38.

test/lang/glob_ptr_field_test.ww

@@ -0,0 +1,26 @@
+// glob_ptr_field_test — a scalar field store through a module-GLOBAL `*struct`
+// pointer (`gp.f = v`) must load the pointer value from gp(SB), not deref the
+// saved-BP word, migrated from test/wcc/989_globptrfield_run.c (inverse-set
+// #47, report-item [58]). cstage's N_DOT-lhs via_ptr scalar store loaded the
+// base with `MOVQ boff(BP),BX`; for a module-global base boff==0, so it emitted
+// `MOVQ (BP),BX` — derefing saved BP as the pointer → store through garbage →
+// SEGV. wwstage was already correct (LEAQ gp(SB),BX; MOVQ (BX),BX); the cstage
+// half aligned UP and the .s is byte-identical, so a behavioral @test is the
+// net. backing is a fresh (zeroed) global; a store that lands in garbage never
+// writes the symbol, so a read-back of backing's field catches the miss. The
+// static-init form `let gp: *S = &backing;` is #48-blocked, so the runtime
+// `gp = &backing` form is used (as in the C twin).
+
+package glob_ptr_field_test;
+
+type S = struct { f: i64, g: i64 };
+
+let backing: S = S { f = 0, g = 0 };
+let gp: *S = nil;
+
+@test fn store_off0() void = {
+	// the exact #58 repro: field at offset 0 through the global pointer.
+	gp = &backing;
+	gp.f = 7;
+	assert(backing.f: i32 == 7);
+};