perf(validator): fast path tag [COMPUTE] for subtag-less tags

`MonomorphicTagImpl[COMPUTE]` is called by `validateTag`/`valueForTag` on
every reference read. For a tag with no subtag — property tags, cell tags,
plain dirtyable/updatable tags, i.e. the overwhelming majority — the result
is always just `revision` (kept current by `dirtyTag`). The
`lastChecked`/`isUpdating`/cycle-guard/`try-finally` machinery exists only to
memoize subtag recursion, so it is pure overhead for these tags.

Return `this.revision` directly when `subtag === null`. The combinator path
is unchanged (it now reuses the already-read `subtag`).

Microbench (1000 subtag-less [COMPUTE]s during a revalidation pass):
~4.71µs -> ~3.90µs (~17%), and no try/finally or field writes on the read.

Full browser suite green: 9340 tests, 9323 pass, 17 skip, 0 fail.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: NullVoxPopuli-ai-agent

packages/@glimmer/validator/lib/validators.ts

@@ -122,6 +122,18 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
   }
 
   [COMPUTE](): Revision {
+    // Fast path for subtag-less tags (property tags, cell tags, plain
+    // dirtyable/updatable tags — the overwhelming majority). With no subtags to
+    // fold in, the value is always just `revision`, which `dirtyTag` keeps
+    // current, so none of the `lastChecked`/`isUpdating`/cycle machinery below
+    // (which exists purely to memoize subtag recursion) is needed. This runs on
+    // every `validateTag`/`valueForTag`, i.e. every reference read.
+    let { subtag } = this;
+
+    if (subtag === null) {
+      return this.revision;
+    }
+
     let { lastChecked } = this;
 
     if (this.isUpdating) {
@@ -135,24 +147,22 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
       this.lastChecked = $REVISION;
 
       try {
-        let { subtag, revision } = this;
-
-        if (subtag !== null) {
-          if (Array.isArray(subtag)) {
-            for (const tag of subtag) {
-              let value = tag[COMPUTE]();
-              revision = Math.max(value, revision);
-            }
+        let { revision } = this;
+
+        if (Array.isArray(subtag)) {
+          for (const tag of subtag) {
+            let value = tag[COMPUTE]();
+            revision = Math.max(value, revision);
+          }
+        } else {
+          let subtagValue = subtag[COMPUTE]();
+
+          if (subtagValue === this.subtagBufferCache) {
+            revision = Math.max(revision, this.lastValue);
           } else {
-            let subtagValue = subtag[COMPUTE]();
-
-            if (subtagValue === this.subtagBufferCache) {
-              revision = Math.max(revision, this.lastValue);
-            } else {
-              // Clear the temporary buffer cache
-              this.subtagBufferCache = null;
-              revision = Math.max(revision, subtagValue);
-            }
+            // Clear the temporary buffer cache
+            this.subtagBufferCache = null;
+            revision = Math.max(revision, subtagValue);
           }
         }