fix(router)!: ctx.theme read in a handler refuses a PPR capture and throws in a cache() miss, like cookies() (#971) - #979

…okies() refuse where cookies() does (#976) (#999)

The identity guards covered cookies(), headers(), the theme reads and a
{ cache: false } variable, but three raw reads went around them:
ctx.request.headers (the same Request in handlers, middleware, loaders and
getRequestContext().request) and getRequestContext().cookie()/cookies().
A "use cache" function keys a ctx or Request argument by route and URL
only, so a header read in its body stored the first caller's value for
every caller; a handler under cache() or on a ppr route stored it in the
shared record or shell, and a loader's own cache() without key() stored it
in its entry.

- The request every ctx exposes gets an own, non-enumerable headers getter
  (server/request-headers.ts shadowRequestHeaders, guarded by
  cookie-store.ts guardRequestHeaders) that runs guardIdentityRead: the
  same scopes, order and error style as headers(), and recorded at the
  read for a loader cache() fill. createRequestContext installs it, and
  createHandlerContext for a request the router builds and matches (the
  progressive-enhancement re-render, a navigation-only capture). No Proxy:
  fetch(ctx.request) and new Request(ctx.request) copy the headers natively
  and never call the getter (they are not guarded; the docs say not to
  make them in a cached body). clone() is shadowed to return a guarded
  clone. A lazy srvx NodeRequest's _request (Node dev and preview servers,
  vercel output) and Node's util.inspect hook run with the guard off, so
  srvx's own clone/body reads and console.log(ctx.request) are not reads;
  the facade stays lazy, so a buffered rawBody is still read.
- Router code reads a request's headers only through requestHeaders(),
  which bypasses the getter (state cookie rotation, request
  classification, HMR and prefetch markers, origin guard, cf-ray, ...).
- getRequestContext().cookie()/cookies() run guardRawCookieRead; the
  cookies() store reads the unguarded _readCookie()/_readCookies().
- key(), a store keyGenerator, condition(), tags() and onError run under
  runIdentityExempt (cache/cache-exec-scope.ts): identity reads there are
  allowed and record nothing. A ppr capture resolves its doc record key
  and the record's tags again under the capture context, so a
  keyGenerator or tags() reading the request (or cookies()) refused every
  capture of its route. The exemption is async-local, so a "use cache"
  body, a loader body and a segment funnel end it on entry: a key() that
  awaited a cached function reading cookies() stored the first visitor's
  cookie.

Breaking: a handler under cache() or on a ppr route, or a "use cache"
body, that reads ctx.request.headers (or a clone's headers) now throws or
refuses the capture. Copy the value in middleware (ctx.set) and include it
in key(), read it in a live loader, or pass it into the "use cache"
function as an argument. The test fixtures and the test-app,
cloudflare-basic and vite-rsc-demo pages that rendered a partition header
from a cached handler now render the middleware copy; vite-rsc-demo's
unreferenced PostRoute is removed.

getRequestContext().theme has been guarded since #979.

Tests: request-headers.test.ts (the getter; fetch, new Request, clone and
util.inspect in every refusing scope on undici; the srvx facade, lazy
rawBody; onError), identity-exempt-scope.test.ts (a cached body, loader
body and funnel started inside an exempt callback are guarded), the SCOPES
table in cookie-store.test.ts (three new surfaces, exempt rows, clone
recording), request-raw-reads.rsc-test.tsx through serveShellRequest
(keyGenerator, condition() and tags() at capture), and dev + production
e2e identity-raw-reads in the router test-app and cloudflare-basic (on
workerd, fetch, new Request and clone inside a cache() boundary).