[mypyc] Fix non-deterministic class struct layout under separate=True

detect_undefined_bitmap() was extending cl.bitmap_attrs in place. Under
separate=True each SCC's analyze_always_defined_attrs is invoked once per
group, and detect_undefined_bitmap recurses through cl.base_mro from the
subclass into its base classes. The seen set passed in dedupes within one
call but is fresh per call, so every subclass-group call re-extends the
shared base class's bitmap_attrs with another copy of the contributions.

The base class's emitted ObjectStruct then grows by one bitmap field per
~32 subclasses processed in the same build. The exact final length is a
function of how many SCCs went through compile_scc_to_ir this run:

  - clean build: every SCC fresh -> base bitmap_attrs accumulates fully
  - incremental build affecting N subclasses: base accumulates a fraction
  - second incremental: yet another count

Subclasses not rebuilt this round still see their base's old, larger
struct layout. Any attribute access on the base segfaults with a
mismatched bitmap-field offset.

Pre-existing in mypyc; only manifested once the prior over-conservative
44-file always-rebuild was lifted (1.20.0.post5), because that wasteful
behavior kept rebuild sets self-consistent.

Fix: compute a fresh local list and assign at the end. The function
becomes naturally idempotent across repeated calls — same input, same
output, regardless of how many groups have visited the class. No new
fields, no serialization changes.

Verified against sqlglot[c] (separate=True, ~100 modules):

  Edit: add a method to MySQLParser (a class with 7 dialect subclasses)
  Before: parser.h struct layout differs between clean and incremental
          builds; make unitc segfaults at first parser-using test.
  After:  parser.h identical between clean and incremental;
          make unitc passes (1163 tests, 0 segfaults).

Author: VaggelisD

mypyc/analysis/attrdefined.py

@@ -424,14 +424,26 @@ def detect_undefined_bitmap(cl: ClassIR, seen: set[ClassIR]) -> None:
     for base in cl.base_mro[1:]:
         detect_undefined_bitmap(base, seen)
 
+    # Compute a fresh list rather than appending to cl.bitmap_attrs in place.
+    # Under separate=True each SCC's analyze_always_defined_attrs recurses
+    # through shared base classes (the `seen` set above only dedupes within
+    # one call), so every subclass group would otherwise re-extend the base's
+    # bitmap_attrs with another copy of the contributions. The base's emitted
+    # struct size would then grow with each call, and later incremental builds
+    # would observe a different (smaller) count and emit a different layout
+    # for the same class — leaving any not-rebuilt subclass with a stale view
+    # of the base's struct, which segfaults on attribute access. Recomputing
+    # fresh makes the function naturally idempotent.
+    new_attrs: list[str] = []
     if len(cl.base_mro) > 1:
-        cl.bitmap_attrs.extend(cl.base_mro[1].bitmap_attrs)
+        new_attrs.extend(cl.base_mro[1].bitmap_attrs)
     for n, t in cl.attributes.items():
         if t.error_overlap and not cl.is_always_defined(n):
-            cl.bitmap_attrs.append(n)
+            new_attrs.append(n)
 
     for base in cl.mro[1:]:
         if base.is_trait:
             for n, t in base.attributes.items():
-                if t.error_overlap and not cl.is_always_defined(n) and n not in cl.bitmap_attrs:
-                    cl.bitmap_attrs.append(n)
+                if t.error_overlap and not cl.is_always_defined(n) and n not in new_attrs:
+                    new_attrs.append(n)
+    cl.bitmap_attrs = new_attrs