fix(gxt-backend): detect SubExpression refs in strict-mode scope threading

The strict-mode scope() callback merge in precompileTemplate was gated by
_templateMayNeedScopeThreading, which only fired when the template had a
PascalCase tag or a free-identifier mustache head. Templates whose only
mustache was `{{on "evt" (fn handler arg)}}` slipped through:

  - The mustache head `on` is skipped (the visitor short-circuits {{on}})
  - There is no PascalCase tag
  - The SubExpression `(fn handler arg)` was never inspected

Result: `handler` and `fn` were never merged into scopeValues, the GXT
compiler emitted `$__fn(this.handler, ...)` (resolving against `this`,
not the strict-mode scope), and the click handler was a no-op.

Extend the gate to also scan for SubExpression heads `(ident ...)`. The
existing `_scopeNameAppearsAsReference` filter still prunes scope entries
the template never references, so loose / Input / Textarea templates stay
unaffected. Fixes the two `Strict Mode - built ins: Can use on and fn` and
`Strict Mode - renderComponent - built ins: Can use on and fn` tests.

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

Author: lifeart

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

@@ -11714,6 +11714,21 @@ function _templateMayNeedScopeThreading(template: string): boolean {
     if (head === 'this' || head === 'on') continue;
     return true;
   }
+  // SubExpression `(ident ...)` syntax — e.g. `{{on "click" (fn handleClick 123)}}`.
+  // The mustache head may be `on` (skipped above) but the modifier args can
+  // reference a strict-mode scope binding via a SubExpression. Detect that
+  // pattern so the scope() callback is consulted for any free identifiers.
+  // Match `(ident` only when preceded by whitespace, `=`, `(`, `{` or `,`
+  // to avoid matching attribute literals like `style="(border)"`.
+  const subExprRe = /(?:^|[\s={(,])\(([A-Za-z_][A-Za-z0-9_-]*)/g;
+  while ((m = subExprRe.exec(template))) {
+    const head = m[1];
+    // `this` cannot appear as a SubExpression head; only `on` is worth
+    // skipping (a SubExpression `(on ...)` would reference the modifier
+    // helper, not a free user binding).
+    if (head === 'this' || head === 'on') continue;
+    return true;
+  }
   return false;
 }