refactor(router-core): unify replaceEqualDeep implementation w/ query (#5067)

Following TanStack/query#9604, this PR
replicates the implementation of `replaceEqualDeep` here, so that both
are more similar (avoid drifting apart over time).

There are no performance changes.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- Performance
- Optimized internal deep-compare and replacement logic to short-circuit
equal values and avoid unnecessary recursion, improving route state
updates. Users may see faster navigations and reduced CPU usage in
complex scenarios.

- Refactor
- Simplified internal implementation while preserving existing behavior
and public APIs. No functional changes or breaking changes for
consumers.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: Sheraff

packages/router-core/src/utils.ts

@@ -217,9 +217,8 @@ export function replaceEqualDeep<T>(prev: any, _next: T): T {
   const next = _next as any
 
   const array = isPlainArray(prev) && isPlainArray(next)
-  const object = !array && isPlainObject(prev) && isPlainObject(next)
 
-  if (!array && !object) return next
+  if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next
 
   const prevItems = array ? prev : getEnumerableOwnKeys(prev)
   if (!prevItems) return next
@@ -234,20 +233,27 @@ export function replaceEqualDeep<T>(prev: any, _next: T): T {
   for (let i = 0; i < nextSize; i++) {
     const key = array ? i : (nextItems[i] as any)
     const p = prev[key]
+    const n = next[key]
+
+    if (p === n) {
+      copy[key] = p
+      if (array ? i < prevSize : prev.hasOwnProperty(key)) equalItems++
+      continue
+    }
+
     if (
-      (array || prev.hasOwnProperty(key)) &&
-      p === undefined &&
-      next[key] === undefined
+      p === null ||
+      n === null ||
+      typeof p !== 'object' ||
+      typeof n !== 'object'
     ) {
-      copy[key] = undefined
-      equalItems++
-    } else {
-      const value = replaceEqualDeep(p, next[key])
-      copy[key] = value
-      if (value === p && p !== undefined) {
-        equalItems++
-      }
+      copy[key] = n
+      continue
     }
+
+    const v = replaceEqualDeep(p, n)
+    copy[key] = v
+    if (v === p) equalItems++
   }
 
   return prevSize === nextSize && equalItems === prevSize ? prev : copy