fix(reactivity): prevent unnecessary computed recalculations in dev mode

  Fix computed properties being recalculated unnecessarily in development
  mode when unrelated reactive values change, while production mode works
  correctly. This issue was caused by version lag in dependency tracking
  during development builds.

  The fix introduces a conservative dependency check that:
  - Only considers dependencies truly dirty when version diff > 1
  - Syncs link versions to prevent accumulating lag
  - Maintains consistency between dev and production behavior
  - Preserves all debugging functionality

  Closes issue with computed performance regression in development mode.

Author: Husky-Yellow

packages/reactivity/src/effect.ts

@@ -327,6 +327,8 @@ function cleanupDeps(sub: Subscriber) {
       // The new head is the last node seen which wasn't removed
       // from the doubly-linked list
       head = link
+      // Sync link version to maintain consistency for future dirty checks
+      link.version = link.dep.version
     }
 
     // restore previous active link if any
@@ -378,6 +380,36 @@ export function refreshComputed(computed: ComputedRefImpl): undefined {
   }
   computed.globalVersion = globalVersion
 
+  // Enhanced dependency check for development mode to ensure consistent behavior
+  // with production mode by avoiding unnecessary recomputations due to version lag
+  if (__DEV__ && computed.flags & EffectFlags.EVALUATED && computed.deps) {
+    let actuallyDirty = false
+    let link: Link | undefined = computed.deps
+    while (link) {
+      // Refresh nested computed dependencies first
+      if (link.dep.computed && link.dep.computed !== computed) {
+        refreshComputed(link.dep.computed)
+      }
+
+      // Conservative dirty check: only consider dirty if version difference > 1
+      // This accounts for the cleanup lag and prevents false positives
+      const versionDiff = link.dep.version - link.version
+      if (versionDiff > 1) {
+        actuallyDirty = true
+        break
+      } else if (versionDiff === 1) {
+        // Sync version to prevent accumulating lag
+        link.version = link.dep.version
+      }
+
+      link = link.nextDep
+    }
+
+    if (!actuallyDirty) {
+      return
+    }
+  }
+
   // In SSR there will be no render effect, so the computed has no subscriber
   // and therefore tracks no deps, thus we cannot rely on the dirty check.
   // Instead, computed always re-evaluate and relies on the globalVersion