cleanup: drop resolved-issue citations from src comments

Sweep all src/**.zig comments that cite resolved issues (issue NNNN /
fix-NNNN / KB-N): the invariant or mechanism each comment states is
kept; the historical citation is dropped, per the no-conclusion-comments
rule. Pure-history parentheticals are removed outright. References to
the 16 still-open issues (0030, 0041-0056) are untouched, as are test
NAMES carrying regression provenance (matching the sanctioned
"Regression (issue NNNN)" example-header convention).

Also removes the issues/0019-import-non-transitive-c-scope/ fixture dir
— the issue is superseded and its behavior is covered by
examples/0706-modules-import-non-transitive.sx (the .md writeup stays).
issues/0030's repro .sx stays: that issue is an open feature request.

Gate: zig build OK; zig build test 426/426; run_examples 541/0; zero
expected/ snapshot churn.

src/sema.zig

@@ -117,7 +117,7 @@ pub const Analyzer = struct {
     /// Module-global integer consts, by bare name → value. Lets an array
     /// dimension written as a named const (`MAX :: 4; [MAX]u8`) fold to a
     /// concrete editor length instead of panicking on the `.int_literal`
-    /// union access (issue 0099). Populated at registration time, so it shares
+    /// union access. Populated at registration time, so it shares
     /// the analyzer's existing intra-pass forward-reference limitation (a const
     /// declared after the struct that uses it resolves to "unknown" length).
     const_int_values: std.StringHashMap(i64),
@@ -226,7 +226,7 @@ pub const Analyzer = struct {
                 const kind = classifyConstDecl(cd);
                 try self.addSymbol(cd.name, kind, ty, node.span);
                 // Record integer-literal consts so a named array dimension
-                // (`MAX :: 4; [MAX]u8`) can fold to a concrete length (issue 0099).
+                // (`MAX :: 4; [MAX]u8`) can fold to a concrete length.
                 if (cd.value.data == .int_literal) {
                     try self.const_int_values.put(cd.name, cd.value.data.int_literal.value);
                 }
@@ -370,7 +370,7 @@ pub const Analyzer = struct {
     /// Fold an array dimension node to a concrete editor length, or null
     /// ("unknown") when it isn't a compile-time integer this index can resolve.
     /// Metadata-only — NEVER panic on an unexpected node shape and never
-    /// fabricate a misleading concrete length (issue 0099). A literal dim is
+    /// fabricate a misleading concrete length. A literal dim is
     /// taken directly; a bare identifier naming an integer const folds to its
     /// recorded value; anything else (unknown name, non-const expression,
     /// out-of-`u32`-range value) is unknown.
@@ -448,7 +448,7 @@ pub const Analyzer = struct {
             }
             // type_expr or identifier — check aliases, enums, structs. A raw
             // reference (`` `s2 ``) skips the builtin classifier and resolves
-            // through user-defined types only (issue 0089).
+            // through user-defined types only.
             if (tn.data == .type_expr or tn.data == .identifier) {
                 const name = if (tn.data == .type_expr) tn.data.type_expr.name else tn.data.identifier.name;
                 const is_raw = if (tn.data == .type_expr) tn.data.type_expr.is_raw else tn.data.identifier.is_raw;
@@ -470,7 +470,7 @@ pub const Analyzer = struct {
     /// Resolve a bare type-name string against the registry (aliases, enums,
     /// structs), falling back to primitive spellings. Unlike `Type.fromName`,
     /// this knows user-defined types; returns `unresolved` when it can't place
-    /// the name. `skip_builtin` is the backtick raw escape (issue 0089) — a raw
+    /// the name. `skip_builtin` is the backtick raw escape — a raw
     /// reference (`` `s2 ``) bypasses the builtin/reserved classifier and
     /// resolves only through user-defined types, mirroring the codegen-side
     /// `TypeResolver.resolveNamed`. Inner names of compound shapes
@@ -503,7 +503,7 @@ pub const Analyzer = struct {
 
     /// The backtick raw bit of an inner type-name node (`` `s2 ``). A compound
     /// shape (`*T`, `?T`, `[]T`, …) stores its inner name as a bare string, so
-    /// this bit must travel ALONGSIDE that name (issue 0089) — otherwise the
+    /// this bit must travel ALONGSIDE that name — otherwise the
     /// resolver re-reads `s2` as the builtin int. Non-leaf nodes are never raw.
     fn typeExprIsRaw(node: *Node) bool {
         return switch (node.data) {