test(hpc/blocked_grid): integration tests + module-level doctest (PR-X3 A6)

Adds the final test-density layer after A1-A5 shipped their inline
#[cfg(test)] coverage:

- src/hpc/blocked_grid/tests.rs (new) — integration tests that span
  multiple submodules: W4 bulk_apply composition, L1→L2 cascade, all
  seven type aliases instantiate, half-square AMX INT8 pattern,
  as_padded_slice footgun verification, const-generic compile-fail
- src/hpc/blocked_grid/mod.rs — module-level doctest demonstrating the
  canonical compose pattern (ShaderMantissaGrid → map_l1 → verify input
  unchanged + output as expected) and #[cfg(test)] mod tests registration

Test count: +17 lib tests + 2 doctests above the A5 baseline (74 + 74).
All 5 gates green.

https://claude.ai/code/session_01UwJuKqP828qyX1VkLgGJFS

Author: claude

src/hpc/blocked_grid/mod.rs

@@ -16,12 +16,62 @@
 //! - `compute`      (worker A4) — `map_base`, `map_tier`, `bulk_apply_base`, `bulk_apply_tier`
 //! - `aliases`      (worker A5) — `ShaderMantissaGrid`, `AmxBf16Grid`, … and L1-L4 alias impls
 //! - `grid_struct_macro` (worker B) — `blocked_grid_struct!` SoA-of-grids macro
+//!
+//! # Zero-dimension compile-fail guard
+//!
+//! Instantiating `BlockedGrid` with a zero block dimension is a **compile-time
+//! error** (the `const { assert!(BR > 0 && BC > 0, …) }` in `new_with_pad` fires
+//! before any code is generated).
+//!
+//! ```compile_fail
+//! use ndarray::hpc::blocked_grid::BlockedGrid;
+//! // BR = 0 is rejected at compile time — this must not compile.
+//! let _ = BlockedGrid::<u64, 0, 64>::new_with_pad(10, 10, 0);
+//! ```
+//!
+//! # Canonical compose pattern
+//!
+//! The idiomatic way to derive a new grid from an existing one:
+//!
+//! ```
+//! use ndarray::hpc::blocked_grid::{BlockedGrid, ShaderMantissaGrid};
+//!
+//! // Build a 128×128 ShaderMantissaGrid (= BlockedGrid<u64, 64, 64>).
+//! // padded_rows() == padded_cols() == 128, so blocks_l1() yields 4 blocks (2×2).
+//! let input: ShaderMantissaGrid = BlockedGrid::new(128, 128);
+//! assert_eq!(input.blocks_l1().count(), 4); // 2 block-rows × 2 block-cols
+//!
+//! // map_l1: derive a transformed grid without mutating input (data-flow Rule #3).
+//! let output = input.map_l1::<u64, _>(|inp, outp| {
+//!     for r in 0..64 {
+//!         let in_row  = inp.row(r);
+//!         let out_row = outp.row_mut(r);
+//!         for (dst, &src) in out_row.iter_mut().zip(in_row.iter()) {
+//!             *dst = src.wrapping_add(1);
+//!         }
+//!     }
+//! });
+//!
+//! // Rule #3 demo: input is unchanged — all cells remain u64::default() == 0.
+//! assert!(input.as_padded_slice().iter().all(|&v| v == 0u64));
+//!
+//! // Output: every cell is input (0) + 1 = 1.
+//! assert!(output.as_padded_slice().iter().all(|&v| v == 1u64));
+//!
+//! // blocks_l1 iterates the 4 base blocks; blocks_l2 requires ≥256×256.
+//! let coords: Vec<_> = output.blocks_l1()
+//!     .map(|b| (b.block_row(), b.block_col()))
+//!     .collect();
+//! assert_eq!(coords, vec![(0, 0), (0, 1), (1, 0), (1, 1)]);
+//! ```
 
 mod base;
 mod iter;
 mod super_block;
 mod compute;
 mod aliases;
+#[cfg(test)]
+mod tests;
 
 pub use aliases::{
     AmxBf16Grid, AmxInt8Grid, HalfSquareU64, ShaderMantissaGrid, SquareF64Stack8, StripF32Stack2, StripF32Stack4,