Fix interception route rewrites for nested dynamic routes (#84413)

### What?

Fixes interception routes with dynamic parameters that were generating
rewrite rules in an incorrect format, preventing proper URL rewriting by
Vercel and Next.js.

### Why?

The failing test
`parallel-routes-and-interception-nested-dynamic-routes` revealed that
interception routes with dynamic segments weren't working correctly when
deployed. The root cause was that the previous implementation using
`safePathToRegexp` produced rewrite destinations that weren't in a
format compatible with direct parameter substitution during the rewrite
process.

When the router tried to rewrite URLs to their intercepted destinations,
the parameter format prevented Vercel/Next.js from properly substituting
the captured values, causing routes to fail.

### How?

Completely rewrote the `generate-interception-routes-rewrites` logic to
use `getNamedRouteRegex` instead of `safePathToRegexp`. This ensures:

1. **Correct rewrite format**: Rewrites are now generated in a format
that allows direct parameter substitution
2. **Parameter consistency**: Source regex is generated first, then its
parameter reference is passed to destination generation to ensure
parameter names match for substitution
3. **Clean URLs**: Added `stripNormalizedSeparators` to prevent
`_NEXTSEP_` internal separator from leaking into client-facing URLs
4. **Stricter matching**: Updated router reducers to pass `next-url`
header for the stricter Next-Url regex matching required by the new
rewrite mechanism

**Testing:**
- Added 23 comprehensive tests for rewrite generation covering all
interception marker types
- Added 18 tests for route matching utilities
- All existing tests pass including the previously failing
`parallel-routes-and-interception-nested-dynamic-routes`

Fixes the failing test:
`test/e2e/app-dir/parallel-routes-and-interception-nested-dynamic-routes/parallel-routes-and-interception-nested-dynamic-routes.test.ts`

NAR-432

Author: wyattjoh

packages/next/errors.json

@@ -865,5 +865,7 @@
   "864": "Missing value for segment key: \"%s\" with dynamic param type: %s",
   "865": "`experimental.rdcForNavigations` is enabled, but `experimental.cacheComponents` is not.",
   "866": "Both \"%s\" and \"%s\" files are detected. Please use \"%s\" instead.",
-  "867": "The %s \"%s\" must export a %s or a \\`default\\` function"
+  "867": "The %s \"%s\" must export a %s or a \\`default\\` function",
+  "868": "No reference found for param: %s in reference: %s",
+  "869": "No reference found for segment: %s with reference: %s"
 }

packages/next/src/client/components/app-router.tsx

@@ -396,7 +396,7 @@ function Router({
     }
   }, [])
 
-  const { cache, tree, nextUrl, focusAndScrollRef } = state
+  const { cache, tree, nextUrl, focusAndScrollRef, previousNextUrl } = state
 
   const matchingHead = useMemo(() => {
     return findHeadInCache(cache, tree[1])
@@ -423,8 +423,9 @@ function Router({
       tree,
       focusAndScrollRef,
       nextUrl,
+      previousNextUrl,
     }
-  }, [tree, focusAndScrollRef, nextUrl])
+  }, [tree, focusAndScrollRef, nextUrl, previousNextUrl])
 
   let head
   if (matchingHead !== null) {

packages/next/src/client/components/layout-router.tsx

@@ -389,7 +389,14 @@ function InnerLayoutRouter({
         new URL(url, location.origin),
         {
           flightRouterState: refetchTree,
-          nextUrl: includeNextUrl ? context.nextUrl : null,
+          nextUrl: includeNextUrl
+            ? // We always send the last next-url, not the current when
+              // performing a dynamic request. This is because we update
+              // the next-url after a navigation, but we want the same
+              // interception route to be matched that used the last
+              // next-url.
+              context.previousNextUrl || context.nextUrl
+            : null,
         }
       ).then((serverResponse) => {
         startTransition(() => {

packages/next/src/client/components/router-reducer/create-initial-router-state.test.tsx

@@ -138,6 +138,7 @@ describe('createInitialRouterState', () => {
       },
       cache: expectedCache,
       nextUrl: '/linking',
+      previousNextUrl: null,
     }
 
     expect(state).toMatchObject(expected)

packages/next/src/client/components/router-reducer/create-initial-router-state.ts

@@ -110,6 +110,7 @@ export function createInitialRouterState({
       // the || operator is intentional, the pathname can be an empty string
       (extractPathFromFlightRouterState(initialTree) || location?.pathname) ??
       null,
+    previousNextUrl: null,
   }
 
   if (process.env.NODE_ENV !== 'development' && location) {

packages/next/src/client/components/router-reducer/handle-mutable.ts

@@ -16,13 +16,15 @@ export function handleMutable(
   // shouldScroll is true by default, can override to false.
   const shouldScroll = mutable.shouldScroll ?? true
 
+  let previousNextUrl = state.previousNextUrl
   let nextUrl = state.nextUrl
 
   if (isNotUndefined(mutable.patchedTree)) {
     // If we received a patched tree, we need to compute the changed path.
     const changedPath = computeChangedPath(state.tree, mutable.patchedTree)
     if (changedPath) {
       // If the tree changed, we need to update the nextUrl
+      previousNextUrl = nextUrl
       nextUrl = changedPath
     } else if (!nextUrl) {
       // if the tree ends up being the same (ie, no changed path), and we don't have a nextUrl, then we should use the canonicalUrl
@@ -84,5 +86,6 @@ export function handleMutable(
       ? mutable.patchedTree
       : state.tree,
     nextUrl,
+    previousNextUrl: previousNextUrl,
   }
 }

packages/next/src/client/components/router-reducer/reducers/navigate-reducer.ts

@@ -391,7 +391,12 @@ export function navigateReducer(
                   new URL(updatedCanonicalUrl, url.origin),
                   {
                     flightRouterState: dynamicRequestTree,
-                    nextUrl: state.nextUrl,
+                    // We always send the last next-url, not the current when
+                    // performing a dynamic request. This is because we update
+                    // the next-url after a navigation, but we want the same
+                    // interception route to be matched that used the last
+                    // next-url.
+                    nextUrl: state.previousNextUrl || state.nextUrl,
                   }
                 )
 

packages/next/src/client/components/router-reducer/reducers/restore-reducer.ts

@@ -45,5 +45,6 @@ export function restoreReducer(
     // Restore provided tree
     tree: treeToRestore,
     nextUrl: extractPathFromFlightRouterState(treeToRestore) ?? url.pathname,
+    previousNextUrl: null,
   }
 }

packages/next/src/client/components/router-reducer/reducers/server-action-reducer.ts

@@ -257,8 +257,14 @@ export function serverActionReducer(
   // Otherwise the server action might be intercepted with the wrong action id
   // (ie, one that corresponds with the intercepted route)
   const nextUrl =
-    state.nextUrl && hasInterceptionRouteInCurrentTree(state.tree)
-      ? state.nextUrl
+    // We always send the last next-url, not the current when
+    // performing a dynamic request. This is because we update
+    // the next-url after a navigation, but we want the same
+    // interception route to be matched that used the last
+    // next-url.
+    (state.previousNextUrl || state.nextUrl) &&
+    hasInterceptionRouteInCurrentTree(state.tree)
+      ? state.previousNextUrl || state.nextUrl
       : null
 
   const navigatedAt = Date.now()

packages/next/src/client/components/router-reducer/router-reducer-types.ts

@@ -254,6 +254,11 @@ export type AppRouterState = {
    * The underlying "url" representing the UI state, which is used for intercepting routes.
    */
   nextUrl: string | null
+
+  /**
+   * The previous next-url that was used previous to a dynamic navigation.
+   */
+  previousNextUrl: string | null
 }
 
 export type ReadonlyReducerState = Readonly<AppRouterState>