fix: template-no-invalid-interactive — honor role=presentation/none and aria-hidden as escape hatches

Premise: peer a11y plugins (jsx-a11y `hasPresentationRole` + aria-hidden
handling inside `isInteractiveElement`; vuejs-accessibility's equivalent)
treat `role="presentation"` / `role="none"` and `aria-hidden`
(boolean / "true" / `{{true}}`) as explicit opt-outs of the interactivity
contract. An element that has opted out via ARIA does not need an
interactive handler check — the handler is authored acknowledging the
element is decorative or hidden from AT.

Conclusion: wire that opt-out into `template-no-invalid-interactive`
before the native/role-based interactivity probe runs.

- Adds `hasNonInteractiveEscapeHatch(node)` covering:
  - `role="presentation"` / `role="none"` (case-insensitive, trimmed,
    first token of a space-separated role list — matches jsx-a11y).
  - `aria-hidden` as bare boolean attribute, the text value `"true"`,
    or the mustache-literal `{{true}}`. `aria-hidden="false"` does NOT
    qualify.
- Visitor short-circuits on escape-hatch hit before computing interactivity.
- Tests: new valid cases for every escape-hatch shape; new invalid
  cases guarding that `aria-hidden="false"` and other roles still flag.
- Audit fixture `tests/audit/no-static-element-interactions/peer-parity.js`
  added to master as evidence of parity. D1 (role=presentation/none) and
  D2 (aria-hidden) divergences previously documented in the Phase-3 audit
  branch are now parity cases in the valid block.

Tracks PR #28 item G1 (escape-hatch awareness across interactive-handler
rules).

Author: johanrd

lib/rules/template-no-invalid-interactive.js

@@ -8,14 +8,64 @@ function hasAttr(node, name) {
   return node.attributes?.some((a) => a.name === name);
 }
 
+function findAttr(node, name) {
+  return node.attributes?.find((a) => a.name === name);
+}
+
 function getTextAttr(node, name) {
-  const attr = node.attributes?.find((a) => a.name === name);
+  const attr = findAttr(node, name);
   if (attr?.value?.type === 'GlimmerTextNode') {
     return attr.value.chars;
   }
   return undefined;
 }
 
+// True iff the attribute's mustache value is the literal boolean `true` —
+// e.g. `aria-hidden={{true}}`. We only treat the unambiguous boolean-literal
+// path; any other expression (helper call, path reference, etc.) is left to
+// runtime and not considered a static escape hatch.
+function isMustacheLiteralTrue(attr) {
+  if (attr?.value?.type !== 'GlimmerMustacheStatement') {
+    return false;
+  }
+  const path = attr.value.path;
+  return path?.type === 'GlimmerBooleanLiteral' && path.value === true;
+}
+
+// Does this element carry a non-interactive escape hatch that peer a11y rules
+// (jsx-a11y, vuejs-accessibility) honor as an opt-out of interactivity checks?
+//   - role="presentation" / role="none" (case-insensitive, trimmed; first token
+//     of a space-separated role list, matching jsx-a11y's `hasPresentationRole`
+//     / ARIA's role fallback semantics).
+//   - aria-hidden as a boolean attribute (bare), as the literal string "true",
+//     or as the mustache-literal `{{true}}`. aria-hidden="false" does NOT
+//     qualify.
+function hasNonInteractiveEscapeHatch(node) {
+  const roleAttr = findAttr(node, 'role');
+  if (roleAttr?.value?.type === 'GlimmerTextNode') {
+    const token = roleAttr.value.chars.trim().toLowerCase().split(/\s+/u)[0];
+    if (token === 'presentation' || token === 'none') {
+      return true;
+    }
+  }
+
+  const ariaHidden = findAttr(node, 'aria-hidden');
+  if (ariaHidden) {
+    // Bare `aria-hidden` (no value) is stored with an empty-chars GlimmerTextNode.
+    if (ariaHidden.value?.type === 'GlimmerTextNode') {
+      const chars = ariaHidden.value.chars;
+      if (chars === '' || chars.trim().toLowerCase() === 'true') {
+        return true;
+      }
+    }
+    if (isMustacheLiteralTrue(ariaHidden)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 const DISALLOWED_DOM_EVENTS = new Set([
   // Mouse events:
   'click',
@@ -143,6 +193,15 @@ module.exports = {
           return;
         }
 
+        // Skip elements that opt out of interactive semantics via
+        // `role="presentation"` / `role="none"` or `aria-hidden`. These are
+        // the same escape hatches honored by jsx-a11y
+        // (`hasPresentationRole` + aria-hidden handling in `isInteractiveElement`)
+        // and vuejs-accessibility.
+        if (hasNonInteractiveEscapeHatch(node)) {
+          return;
+        }
+
         // Skip if element is interactive
         if (isInteractive(node)) {
           return;