TL;DR: Add an experimental FSR Ray Regeneration backend on Windows, run the K

network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.

Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling

FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
  compose compute shaders. They run AMD's FidelityFX denoiser
  (amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
  vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
  patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
  backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
  runs an internal Super Sampling stage (feature 1) to upscale. If SR is
  unavailable and output != render size, the frame fails; it is never
  returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
  FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
  matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
  compile script.

Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
  because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
  (VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
  intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
  D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
  replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
  longer require near2rnd == out2rnd. Both values must still be in (0, 1].

K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
  (D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
  its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
  wave could overwrite its hb rows while a slower wave still read them for a
  later head, giving rare wrong results on gfx1101 (enc0 outputs differing
  between identical launches).

Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
  install_dependencies.py to install pinned NVIDIA dependencies with staged,
  hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
  on some synthetic runs, but player temporal exactness is unresolved.

Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
  benchmark_k_hip, build_capture_runtime, test_k_model and the
  zluda-k-output-capture patch. Captured weights and models are private
  local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
  prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.

Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
  rr-model-cache docs. Add windows-parity-handoff.md and
  windows-parity-continuation-prompt.md.

tools/windows/benchmark_k_hip.py

@@ -0,0 +1,107 @@
+"""Compare strict HIP K candidates against a fixed model on synthetic temporal frames.
+
+Each candidate overlays only named code objects in a private model copy. All five
+frame products must match the baseline hashes exactly. Raw files created by this
+run are hashed and deleted immediately after each process; existing evidence is
+never removed. Reported frame timestamps include Vulkan front/back and CPU gaps.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import sys
+
+repo = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(repo / '.tools/python/vendor'))
+import numpy as np
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    for name in ('runner', 'model', 'case', 'output'):
+        parser.add_argument('--' + name, required=True, type=lambda p: Path(p).resolve())
+    parser.add_argument('--candidate', action='append', default=[], metavar='LABEL=OBJECT_DIRECTORY')
+    parser.add_argument('--repeats', type=int, default=25)
+    args = parser.parse_args()
+    if not args.output.is_relative_to((repo / 'build').resolve()):
+        parser.error('output must stay under ignored build/')
+    args.output.mkdir(parents=True, exist_ok=False)
+    frame_count = sum(1 for line in args.case.read_text().splitlines()
+                      if line.split() and line.split()[0] in ('frame', 'frame_auto'))
+    if not frame_count:
+        parser.error('case must contain explicit frame or frame_auto entries')
+    expected_products = {f'frame-{i}.{suffix}.bin' for i in range(frame_count)
+                         for suffix in ('312', '288', '296', '304', 'head')}
+    env = {k: v for k, v in os.environ.items() if not k.startswith('D4R_')}
+    env['PATH'] = str(repo / '.tools/therock-10.2.0a20260929/_rocm_sdk_core/bin') + os.pathsep + env['PATH']
+    report = {'synthetic': True, 'gameAccessed': False, 'exactGate': 'all five frame products',
+              'timingScope': 'Vulkan front + HIP network + Vulkan back, including CPU synchronization gaps',
+              'runnerSha256': hashlib.sha256(args.runner.read_bytes()).hexdigest(),
+              'caseSha256': hashlib.sha256(args.case.read_bytes()).hexdigest(), 'runs': []}
+    reference = None
+    variants = [('baseline', None)] + [tuple(s.split('=', 1)) for s in args.candidate]
+    for label, source in variants:
+        if not re.fullmatch(r'[a-zA-Z0-9_-]+', label):
+            parser.error('candidate label must be letters, digits, underscores or hyphens')
+        output = args.output / label
+        output.mkdir()
+        model = args.model
+        row = {'label': label, 'objects': {}}
+        if source:
+            model = output / 'model'
+            shutil.copytree(args.model, model)
+            inputs = sorted(Path(source).resolve().glob('*.hsaco')) + sorted(Path(source).resolve().glob('*.spv'))
+            for obj in inputs:
+                destination = model / 'hip' / obj.name if obj.suffix == '.hsaco' else model / obj.name
+                if not destination.is_file():
+                    raise RuntimeError('candidate must replace an existing object: ' + obj.name)
+                shutil.copy2(obj, destination)
+                row['objects'][obj.name] = hashlib.sha256(obj.read_bytes()).hexdigest()
+            if not row['objects']:
+                raise RuntimeError('candidate contains no objects')
+            manifest = json.loads((model / 'model.json').read_text())
+            for name, digest in row['objects'].items():
+                manifest['sha256'][name] = digest
+            manifest['experimentalOverlay'] = row['objects']
+            (model / 'model.json').write_text(json.dumps(manifest, indent=2) + '\n')
+        command = [str(args.runner), str(model), str(args.case), str(output / 'frames'), str(args.repeats), 'hip']
+        with (output / 'stdout.log').open('wb') as out, (output / 'stderr.log').open('wb') as err:
+            result = subprocess.run(command, env=env, stdout=out, stderr=err, timeout=240)
+        row['exitCode'] = result.returncode
+        hashes = {}
+        finite = True
+        for path in sorted((output / 'frames').glob('frame-*.bin')):
+            hashes[path.name] = hashlib.sha256(path.read_bytes()).hexdigest()
+            if path.name.endswith('.312.bin'):
+                values = np.fromfile(path, '<f2').astype('f4')
+                finite = finite and bool(np.isfinite(values).all() and np.var(values) > 1e-6)
+            if not path.resolve().is_relative_to(args.output):
+                raise RuntimeError('raw cleanup escaped the fresh output directory')
+            path.unlink()
+        row['hashes'] = hashes
+        row['finiteNonuniformOutput'] = finite
+        if reference is None:
+            reference = hashes
+        row['differentProducts'] = [k for k in sorted(set(hashes) | set(reference)) if hashes.get(k) != reference.get(k)]
+        row['exact'] = result.returncode == 0 and set(hashes) == expected_products and not row['differentProducts'] and finite
+        text = (output / 'stdout.log').read_text(errors='replace')
+        timing = re.search(r'full native frame: ([0-9.]+) us GPU median \(min ([0-9.]+)\)', text)
+        if timing:
+            row['measuredMedianUs'] = float(timing[1])
+            row['measuredMinUs'] = float(timing[2])
+        report['runs'].append(row)
+        (args.output / 'summary.json').write_text(json.dumps(report, indent=2) + '\n')
+        print(f'{label}: exact={row["exact"]} differing={len(row["differentProducts"])} median_us={row.get("measuredMedianUs")}', flush=True)
+        if result.returncode:
+            return 1
+    report['passed'] = all(row['exact'] for row in report['runs'])
+    (args.output / 'summary.json').write_text(json.dumps(report, indent=2) + '\n')
+    return 0 if report['passed'] else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())