Build native Windows packages for both RDNA4 targets

Add explicit gfx1200/gfx1201 builds, runtime selection and per-target
code objects. Guard staging, packaging and installation against mixed
architectures; retain gfx1201 compatibility and strict K/M arithmetic.

Adapt realdody's target configuration and MSVC binary16/BOOL portability
fixes from ae530b0. Do not import its forced gfx12 layout on RDNA3.
Add exhaustive binary16 and C++/PowerShell target contract regressions.

Validation: 20 CTest gates on RX 9070 XT; four software-only gfx1200 gates;
MSVC portability compile checks; exact 4K K async and M control outputs;
isolated package install/restore and mixed-target rejection tests.
No physical gfx1200 validation is claimed.

Co-authored-by: realdody <[email protected]>

tools/windows/binary16_probe.cpp

@@ -0,0 +1,45 @@
+#include "binary16.h"
+#include <cstdio>
+#include <initializer_list>
+#include <stdexcept>
+
+static void check(double value, uint16_t expected) {
+    const auto actual = d4r::diag::binary16::half_bits(value);
+    if (actual != expected) throw std::runtime_error("binary16 rounding mismatch");
+}
+int main() {
+    using namespace d4r::diag::binary16;
+    try {
+        unsigned encodings = 0, boundaries = 0;
+        for (unsigned bits = 0; bits < 65536; ++bits) {
+            if ((bits & 0x7c00) == 0x7c00 && (bits & 0x3ff)) continue;
+            check(half_value(uint16_t(bits)), uint16_t(bits));
+            ++encodings;
+        }
+        for (unsigned bits = 0; bits < 0x7bff; ++bits) {
+            const double low = half_value(uint16_t(bits)), high = half_value(uint16_t(bits + 1));
+            const double midpoint = (low + high) * 0.5;
+            const uint16_t tie = uint16_t(bits + (bits & 1));
+            check(midpoint, tie); check(-midpoint, uint16_t(tie | 0x8000));
+            check(std::nextafter(midpoint, low), uint16_t(bits));
+            check(std::nextafter(midpoint, high), uint16_t(bits + 1));
+#if !defined(_MSC_VER)
+            for (double value : {midpoint, -midpoint, std::nextafter(midpoint, low), std::nextafter(midpoint, high)}) {
+                const _Float16 native = static_cast<_Float16>(value);
+                uint16_t expected; std::memcpy(&expected, &native, sizeof(expected));
+                check(value, expected);
+            }
+#endif
+            ++boundaries;
+        }
+        check(65519.0, 0x7bff); check(65520.0, 0x7c00);
+        check(-65520.0, 0xfc00);
+        check(std::numeric_limits<double>::denorm_min(), 0);
+        check(-std::numeric_limits<double>::denorm_min(), 0x8000);
+        check(std::numeric_limits<double>::quiet_NaN(), 0x7e00);
+        std::printf("PASS BINARY16 encodings=%u rounding_boundaries=%u\n", encodings, boundaries);
+        return 0;
+    } catch (const std::exception& e) {
+        std::fprintf(stderr, "FAIL BINARY16 %s\n", e.what()); return 5;
+    }
+}