fix(gxt-backend): compare _templateFn for route template identity

GXT's runtime template factory returns a fresh wrapper object on every
`templateFactory(owner)` invocation, and `buildRenderState` calls the
factory on each route render. The root-outlet re-render fast-path used
strict object identity (`lastRouteTemplate !== newTemplate`) to detect a
template swap, so even renders of the SAME route template were treated
as a swap and forced a full re-render (innerHTML = ''). That destroyed
DOM node identity across `/colors/red -> /colors/green` style transitions
and broke the "stable DOM when the model changes" invariant.

Compare the underlying `_templateFn` (the compiled function shared across
fresh wrappers) so two wrappers around the same template stay on the
in-place fast-path. Falls back to object identity for non-runtime
templates so the test-helpers fresh-compile case (different `_templateFn`)
still triggers a full re-render.

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

Author: lifeart

packages/@ember/-internals/glimmer/lib/templates/root.ts

@@ -1008,8 +1008,25 @@ export default function createRootTemplate(_owner: any) {
       // ('index') but hand us a fresh `compile()` template on each render.
       // If we stayed on the fast-path in that case, we would only update
       // model cells and miss the new template's DOM content.
-      const routeTemplateChanged =
-        lastRouteTemplate !== null && newTemplate && lastRouteTemplate !== newTemplate;
+      //
+      // NOTE: GXT's runtime template factory (precompileTemplate) returns a
+      // fresh wrapper object for every `templateFactory(owner)` invocation,
+      // and `buildRenderState` calls the factory on every route render. As a
+      // result, `lastRouteTemplate !== newTemplate` is `true` even when the
+      // route renders the SAME template (the underlying `_templateFn` is the
+      // same instance). Treating that as a template swap forces a full
+      // re-render that destroys DOM node identity and breaks the "stable DOM
+      // when the model changes" invariant. Compare the underlying
+      // `_templateFn` (set on every gxt-runtime-template wrapper) so two
+      // wrappers around the same compiled function are recognized as equal.
+      const routeTemplateChanged = (() => {
+        if (lastRouteTemplate === null || !newTemplate) return false;
+        if (lastRouteTemplate === newTemplate) return false;
+        const lastFn = (lastRouteTemplate as any)?._templateFn;
+        const newFn = (newTemplate as any)?._templateFn;
+        if (lastFn && newFn && lastFn === newFn) return false;
+        return true;
+      })();
 
       // If same route template AND nested outlets haven't changed, try to
       // update existing cells in-place to preserve DOM node identity.