[AlexanderSoftCode]

Context

Conv2d ignored an explicit set_precision("float32") on a GPU: it stayed on the fp16 WMMA
path and only warned that the policy was ignored. It now honors the request by binding the fp32
fallback, and warns that this is much slower. One commit.

Conv precision

set_precision(...)	GPU with WMMA	before
not called / "float16"	WMMA, no warning	same
"float32"	fp32 fallback, slow warning	WMMA, "policy is ignored"
"float64"	fp32 fallback, slow warning that also says float64 isn't honored	WMMA, "policy is ignored"

• The binding happens in _compile_for_device. _apply_precision re-runs it on an already
  compiled layer, so set_precision() works before or after to()/finalize(), and
  "float32" → "float16" returns to WMMA.
• The warning has no speed ratio (it would go stale as the paths change). It says
  THIS IS MUCH SLOWER and points to set_precision('float16') or leaving it unset.
• float64 still computes in float32: the fallback is fp32 only.
• Model.set_precision and the Conv2d docstrings now describe this.

Behavior changes

• set_precision("float32") or ("float64") on a GPU now gives slower, real fp32 convolutions
  instead of fp16 WMMA ones, plus a UserWarning. Not calling set_precision or using
  "float16" is unchanged.
• A model saved under "float32" loads onto the fallback path and warns once.

Testing

• python3 -m unittest discover tests: 1125 tests pass on NumPy and CuPy (59 skipped), in the
  ROCm devcontainer.
• 5 new GPU-only tests (skipped on NumPy or without WMMA): "float32" and "float64" bind the
  fallback and warn once; None and "float16" stay on WMMA silently; "float32" → "float16"
  rebinds WMMA; the "float32" forward is bit-exact with the fallback. The first, second and
  last fail on the old code. The other two pin behavior that was already correct.
• test_mismatched_policy_warns_once_naming_both_dtypes now reads the effective dtype after
  applying float64, since that changes the binding.
• Checked by hand on the RX 9070 XT: in examples/cifar10/v1_cifar10.py I changed
  set_precision("float16") to set_precision("float32"). The warning appears as intended and
  training continues on the fallback, which is far slower than the kernel path.
• Not verified: CUDA, the RTX 3050, and a GPU without tensor cores.

Follow-ups (out of scope)

• tests/ops/test_conv_cast_kernel.py:55 (test_matches_clip_and_astype) emits
  RuntimeWarning: overflow encountered in cast. The test intentionally casts inputs above
  65504 to fp16, which overflow to inf, and doesn't suppress the expected NumPy warning. The
  assertions are correct; the fix is in the next PR.