kernels: build the denoiser's output kernel natively, authorized separately

Ray Reconstruction's eleven DLSS-D Swin layers still run ZLUDA's compile of
NVIDIA's PTX; at 1280x720 -> 3840x2160 on gfx1201 they are 30.2 of a 31.6 ms
frame. The denoiser's high-fidelity output kernel is the first one with a native
replacement: make_ptx.py replaces its whole-texel RGBA16F store
(sust.b.2d.v4.b16.zero) through d4r_sust_v4b16, kernels/build.sh builds the pair
as the `rr` family, and packaging builds it into every target folder including
the RDNA4 FP8 ones.

Both libraries define modules named cuda_dldn_engine_*, with different text, so
one manifest cannot take the union of their hashes: kernel_manifest.py now takes
the denoiser DLL as --rr-dll and lets only its hashes authorize a
cuda_dldn_engine_* binary, and package_release.sh passes it when the denoiser is
bundled.

Verified in the D3D12 harness with Ray Reconstruction at 1280x720 -> 3840x2160:
the output kernel drops from 1.44 to 1.00 ms/frame and the 66 MB raw output is
byte-identical to the run with every kernel translated.

docs/native-kernels.md gains the denoiser family, the per-kernel cost table and
the instruction counts that show why the Swin layers are the remaining work.

kernels/tex/make_ptx.py

@@ -99,6 +99,13 @@ SUST_EXTERN = """.extern .func d4r_sust_v2b16
 )
 ;
 """
+SUST4_EXTERN = """.extern .func d4r_sust_v4b16
+(
+	.param .b64 d4r_h0, .param .b32 d4r_h1, .param .b32 d4r_h2, .param .b16 d4r_h3,
+	.param .b16 d4r_h4, .param .b16 d4r_h5, .param .b16 d4r_h6
+)
+;
+"""
 SUSTP_EXTERN = """.extern .func d4r_sust_p_v4b32
 (
 	.param .b64 d4r_t0, .param .b32 d4r_t1, .param .b32 d4r_t2, .param .b32 d4r_t3, .param .b32 d4r_t4,
@@ -115,14 +122,31 @@ SUSTB32_EXTERN = """.extern .func d4r_sust_b32
 """
 SUSTB32_RE = re.compile(r"^sust\.b\.2d\.b32\.zero \[(%rd\d+), \{(%r\d+),(%r\d+)\}\], \{(%r\d+)\};$")
 SUST_RE = re.compile(r"^sust\.b\.2d\.v2\.b16\.zero \[(%rd\d+), \{(%r\d+),(%r\d+)\}\], \{(%rs\d+),(%rs\d+)\};$")
+SUST4_RE = re.compile(r"^sust\.b\.2d\.v4\.b16\.zero \[(%rd\d+), \{(%r\d+),\s*(%r\d+)\}\], \{(%rs\d+),\s*(%rs\d+),\s*(%rs\d+),\s*(%rs\d+)\};$")
 
 
 SUST_KINDS = set(os.environ.get("D4R_SUST_KINDS", "b16,p,b32").split(","))
 
 
 def replace_sust(lines):
-    out, n = [], {"b16": 0, "p": 0, "b32": 0}
+    out, n = [], {"b16": 0, "v4b16": 0, "p": 0, "b32": 0}
     for line in lines:
+        mh = SUST4_RE.match(line.strip()) if "b16" in SUST_KINDS else None
+        if mh:
+            s, x, y, *v = mh.groups()
+            st = "\n".join(f"\t.param .b16 v{i};\n\tst.param.b16 [v{i}+0], {r};" for i, r in enumerate(v))
+            out.append(f"""{{
+	.param .b64 u0;
+	st.param.b64 [u0+0], {s};
+	.param .b32 u1;
+	st.param.b32 [u1+0], {x};
+	.param .b32 u2;
+	st.param.b32 [u2+0], {y};
+{st}
+	call d4r_sust_v4b16, (u0, u1, u2, v0, v1, v2, v3);
+}}""")
+            n["v4b16"] += 1
+            continue
         mb = SUSTB32_RE.match(line.strip()) if "b32" in SUST_KINDS else None
         if mb:
             s, x, y, v = mb.groups()
@@ -414,7 +438,8 @@ ENC0_REF = "rrlite_enc0_4x4_mvhi_hdr_folded"
 SUST_ONLY_RE = re.compile(r"^(hiluma_engine_output_depth(inv|reg)_mv(hi|lo)_(hdr|ldr)(_max)?_v[12]_rel|"
                           r"rrlite_post_3_[12]_mv(hi|lo)_(hdr|ldr)(_folded)?|"
                           r"rrlite_enc0_4x4_mv(hi|lo)_(hdr|ldr)|rrlite_dec0_4x4|"
-                          r"rrlite_downsample_kernel_(static|dynamic)_(hdr|ldr))$")
+                          r"rrlite_downsample_kernel_(static|dynamic)_(hdr|ldr)|"
+                          r"cuda_dldn_engine_hkpn_output_kernel_transformer(_diamond_wallaby)?)$")
 ENC0_RE = re.compile(r"^rrlite_enc0_4x4_mv(hi|lo)_(hdr|ldr)_folded$")
 
 
@@ -536,7 +561,7 @@ def main():
         if n["dec8"] != k["dec8"]:
             sys.exit(f"{name}: {n['dec8']} e4m3 decodes, expected {k['dec8']}")
         k = dict(k, extern=k["extern"] + DEC8_EXTERN)
-    extern = k["extern"] + (SUST_EXTERN if n["b16"] else "") + (SUSTP_EXTERN if n["p"] else "") + (SUSTB32_EXTERN if n["b32"] else "")
+    extern = k["extern"] + (SUST_EXTERN if n["b16"] else "") + (SUST4_EXTERN if n.get("v4b16") else "") + (SUSTP_EXTERN if n["p"] else "") + (SUSTB32_EXTERN if n["b32"] else "")
     text = "\n".join(head[:entry]) + "\n" + extern + "\n".join(body + tail)
     out.write_text(text)
     print(f"{out}: {len(text.splitlines())} lines, surface stores replaced: {n}")