[AlexanderSoftCode]

Context

Every BatchNorm in the CIFAR-10 model feeds a ReLU, which costs its own read +
write pass in each direction: 0.28 + 0.44 ms per step on the RX 9070 XT, more
than BatchNorm's forward takes after #18. This PR applies the activation inside
the BatchNorm kernels and skips the activation layer. It follows #18 (Part 2 of
the BatchNorm plan). Two commits: the kernels learn a slope, then the model
uses it. Neither is mechanical.

Kernels: one slope for every case

The BatchNorm kernels take alpha and compute z = fmaf(x - mean, scale, beta),
out = z > 0 ? z : alpha * z. alpha = 1 is no activation (the default, which
behaves exactly as before), 0 is ReLU and anything else LeakyReLU, so there is
no separate fused code path.

The backward recomputes z from x, which it already reads, and uses the
activation's gradient in place of dy in both grad_sums and the elementwise
pass. No extra memory and no extra bandwidth: one FMA and a select per element.
z, the activation and its gradient are a single source string shared by the
RawKernels and the ElementwiseKernels (through preamble), so the backward's
mask is bit-identical to the forward's.

Model: fusion at finalize

Model.finalize(input_shape, fuse_kernels=True) finds a BatchNorm directly
followed by a ReLU or LeakyReLU (exact types, so subclasses never fuse). On
CuPy, BatchNorm applies the activation and the activation layer is skipped in
both directions.

Fusion is re-planned after every to(). A model fused on CuPy and moved to
NumPy would otherwise skip its ReLUs and silently give wrong outputs. Instead
it runs every layer again, and re-fuses when moved back.

model.layers, save(), the manifest and the weight keys are unchanged.
fuse_kernels isn't saved: load() fuses again by default.

Results (RX 9070 XT, cifar10_breakdown.py, median of 3)

per step	after #18	this PR
model.train()	5.889 ms	5.119 ms (-13.1 %)
ReLU forward + backward, GPU	0.72	removed
BatchNorm forward, GPU	0.404	0.406
BatchNorm backward, GPU	0.842	0.761

Together with #18: 6.691 -> 5.119 ms per step (-23.5 %). With alpha = 1 (no
fusion) the step time is unchanged (5.913 vs 5.889 ms).

Behavior changes

• On CuPy, by default, a ReLU or LeakyReLU directly after a BatchNorm no longer
  runs as its own layer. The model's outputs are unchanged, but that layer's
  output attribute is no longer updated. Nothing in the package reads it.
  Pass finalize(..., fuse_kernels=False) to keep every layer.
• A fused LeakyReLU uses an fp32 slope (BatchNorm is precision-exempt), so
  under set_precision('float16') it is very slightly more accurate than the
  unfused one, whose slope is fp16 (0.0099945 for 0.01).
• A NaN or inf gradient at an inactive fused ReLU unit gives 0, the same as
  ReLU's GPU backward since perf(relu): fuse the GPU backward into one select kernel #15.
• NumPy is unaffected.

Testing

• python3 -m unittest discover tests: 1152 tests pass on NumPy and CuPy (72
  skipped), at each commit.

• Fused ReLU and LeakyReLU against the fallback BatchNorm followed by the
  activation's own fallback: output, dx, dgamma and dbeta in training, plus the
  inference output. The inputs keep every z away from 0, so rounding can't flip
  a mask. Fails if grad_sums ignores the activation or inference ignores alpha.

• NaN gradient at an inactive unit: with ReLU, dx, dgamma and dbeta stay
  NaN-free and match the unfused GPU chain; with LeakyReLU the NaN propagates.
  Fails without the select.

• Model level, Conv -> BatchNorm -> ReLU -> Conv -> BatchNorm -> LeakyReLU in
  strict fp32:

  • fused and unfused give the same outputs, gradients and Adam step;
  • a fused model moved to NumPy runs every layer and matches the GPU
    predictions, then re-fuses on the way back;
  • save + load keeps both activations in the manifest and re-fuses.

  These fail if to() doesn't re-plan fusion, or if Model.forward runs
  self.layers.

• The Adam-step check skips the Conv2d biases in front of a BatchNorm. Their
  true gradient is 0, so Adam's first step (about lr * sign(g)) turns rounding
  noise into ~lr-sized differences. Their gradients are still compared.

• Measured on an RX 9070 XT (ROCm). Not yet run on the RTX 3050 (CUDA),
  including CUDA compiling the elementwise kernels' new preamble.

• LeakyReLU fusion is tested for correctness, but not benchmarked: the CIFAR-10
  model only uses ReLU.

Follow-ups (out of scope)

• Inference: fold BatchNorm into the preceding conv's weights at predict time.