fix(gxt-backend): drain leaked classic reactors between tests

_renderComponentGxt registers a reactor in _classicReactors (validator.ts)
and tries to unhook it via registerDestructor(owner, doDestroy). When the
caller passes a synthetic owner ({} — the documented default for the
renderComponent API), registerDestructor silently fails (plain objects
are not destroyable), so the reactor outlives its test.

On the next test's classic-tag dirty (e.g. typing in a textarea, swap of
a dynamic component, or any @Tracked write), the leaked reactor fires
_doRender against the prior test's detached target and triggers
__gxtSyncDomNow, which clobbers the active test's DOM through the
shared force-rerender path.

Symptom cluster on testem (single-page run, modules load sequentially):
  - <Textarea> / {{textarea}} cut/input/change tests
  - curly didReceiveAttrs deprecation
  - dynamic component swap-out destroy
  - error recovery during initial render
  - renderComponent siblings (1 of 2)
  - browser timeout 1200s after the textarea cluster wedges sync state

All affected modules pass in isolation; the failures are pure
cumulative-state leak symptoms. __gxtCleanupActiveComponents already
clears every other module-level Set/Map between tests; _classicReactors
is the one that was missing.

Fix: expose __gxtClearClassicReactors from validator.ts and call it
from __gxtCleanupActiveComponents. Smoke (14 modules / 333 tests)
passes; affected modules pass individually.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: lifeart

packages/@ember/-internals/gxt-backend/compile.ts

@@ -5822,6 +5822,15 @@ setInterval(() => {
   if (typeof (globalThis as any).__gxtClearIfWatchers === 'function') {
     (globalThis as any).__gxtClearIfWatchers();
   }
+  // Drain leaked classic reactors. _renderComponentGxt registers a reactor in
+  // _classicReactors and tries to unhook it via registerDestructor(owner, …);
+  // when owner is a synthetic {} (the documented default), registerDestructor
+  // silently fails, leaving the reactor live. On the next test's classic-tag
+  // dirty (e.g. typing in a textarea) the leaked reactor fires _doRender on
+  // the prior test's detached target and clobbers shared GXT sync state.
+  if (typeof (globalThis as any).__gxtClearClassicReactors === 'function') {
+    (globalThis as any).__gxtClearClassicReactors();
+  }
   // Destroy cached engine instances from {{mount}} so Namespace.destroy()
   // removes them from NAMESPACES (prevents "Should not have any NAMESPACES" failures).
   if ((globalThis as any).__gxtEngineInstances) {

packages/@ember/-internals/gxt-backend/validator.ts

@@ -655,6 +655,15 @@ export function registerClassicReactor(cb: () => void): () => void {
     _classicReactors.delete(cb);
   };
 }
+// Drain all reactors. Used by __gxtCleanupActiveComponents between tests:
+// reactors registered by _renderComponentGxt with a synthetic owner ({}) can
+// outlive their test because registerDestructor silently fails on plain
+// objects, leaving the reactor in this Set. On the next test's classic-tag
+// dirty (e.g. textarea input), the leaked reactor fires _doRender against an
+// already-detached target and clobbers shared GXT sync state.
+(globalThis as any).__gxtClearClassicReactors = function () {
+  _classicReactors.clear();
+};
 function _fireClassicReactors() {
   if (_classicReactors.size === 0) return;
   // Copy to avoid mutation during iteration