chore(ndarray): migrate benches off nightly #![feature(test)] to criterion 0.5 + Tier A clippy fixes

User directive: stable Rust 1.94.1 only — no nightly features anywhere.
The bench tests used #![feature(test)] + extern crate test + #[bench]
(unstable libtest_bench framework), blocking CI on stable. Migrated all
13 benches to criterion 0.5 (already established workspace pattern via
crates/p64 + crates/phyllotactic-manifold).

Files migrated (10 source files; append.rs/construct.rs/numeric.rs were
already criterion-based; Cargo.toml + ndarray-rand/Cargo.toml had the
[[bench]] + criterion dev-dep prep already in working tree):

  benches/bench1.rs        (1106 LOC, ~80 #[bench] fns + mat_mul! macro)
  benches/iter.rs          (436 LOC, ~30 #[bench] fns)
  benches/par_rayon.rs     (182 LOC, rayon-feature-gated)
  benches/zip.rs           (133 LOC)
  benches/to_shape.rs      (95 LOC)
  benches/higher-order.rs  (93 LOC)
  benches/chunks.rs        (87 LOC)
  benches/gemv_gemm.rs     (75 LOC)
  benches/reserve.rs       (31 LOC)
  ndarray-rand/benches/bench.rs (31 LOC)

Mechanical conversion pattern:
  BEFORE: #[bench] fn name(b: &mut Bencher) { b.iter(|| ...); }
  AFTER:  fn name(c: &mut Criterion) { c.bench_function("name", |b| b.iter(|| ...)); }
          criterion_group!(benches, name1, name2, ...);
          criterion_main!(benches);

Bench function names preserved exactly so `cargo bench --bench foo name`
keeps working. Wrapped inputs with criterion's black_box where the
original used test::black_box.

Special handling:
- bench1.rs's mat_mul! macro now generates pub fn $name(c: &mut Criterion)
  inside each module + a pub fn group(c) that calls them all. Top-level
  criterion_group!(matmul_benches, mat_mul_f32::group, ...) registers
  all 30 generated benches.
- bench1.rs split into 11 criterion_groups (iter/sum/add/scalar/
  add_strided/iadd_scalar/iter_misc/dot/dimensionality/matmul/std) for
  readability; criterion_main! aggregates them all.
- iter.rs splits #[cfg(feature = "std")] benches into a separate
  criterion_group with conditional criterion_main! inclusion.

Tier A clippy fixes (per user request to ship clean):
- examples/life.rs:1 + tests/assign.rs:1 + tests/array.rs:1 +
  benches/bench1.rs:1 + benches/iter.rs:1 — added
  #[allow(clippy::reversed_empty_ranges)] for the s![1..-1, ..]
  Python-style negative-indexing macro pattern (false positive — clippy
  can't see through s! macro).
- tests/oper.rs:300 — replaced unsafe Vec::with_capacity + set_len
  uninit pattern with proper MaybeUninit<A>::uninit + write per slot
  + ManuallyDrop transmute. SAFETY comments document each unsafe block.

Verification (per user "use clippy not check"):
  cargo clippy --benches --tests --examples --features rayon --no-deps
  → 0 errors in benches/tests/examples (down from 18+).

5 pre-existing lib code errors remain (NOT introduced here, NOT in scope
for this commit):
- src/hpc/quantized.rs:431 + src/hpc/blackboard.rs:484-485 +
  src/hpc/jitson/parser.rs:487 — clippy::approx_constant
  (literal PI values; should use std::f{32,64}::consts::PI)
- src/hpc/renderer.rs:428 — clippy::absurd_extreme_comparisons

These are lib-level tech debt visible to `cargo clippy --lib` and
require separate fix commits.

Author: claude

Cargo.lock

@@ -71,6 +71,56 @@ quickcheck = { workspace = true }
 approx = { workspace = true, default-features = true }
 itertools = { workspace = true }
 ndarray-gen = { workspace = true }
+criterion = { version = "0.5", features = ["html_reports"] }
+
+[[bench]]
+name = "append"
+harness = false
+
+[[bench]]
+name = "bench1"
+harness = false
+
+[[bench]]
+name = "chunks"
+harness = false
+
+[[bench]]
+name = "construct"
+harness = false
+
+[[bench]]
+name = "gemv_gemm"
+harness = false
+
+[[bench]]
+name = "higher-order"
+harness = false
+
+[[bench]]
+name = "iter"
+harness = false
+
+[[bench]]
+name = "numeric"
+harness = false
+
+[[bench]]
+name = "par_rayon"
+harness = false
+required-features = ["rayon"]
+
+[[bench]]
+name = "reserve"
+harness = false
+
+[[bench]]
+name = "to_shape"
+harness = false
+
+[[bench]]
+name = "zip"
+harness = false
 
 [features]
 default = ["std"]

Cargo.toml

@@ -1,32 +1,30 @@
-#![feature(test)]
-
-extern crate test;
-use test::Bencher;
-
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use ndarray::prelude::*;
 
-#[bench]
-fn select_axis0(bench: &mut Bencher)
-{
+fn select_axis0(c: &mut Criterion) {
     let a = Array::<f32, _>::zeros((256, 256));
     let selectable = vec![0, 1, 2, 0, 1, 3, 0, 4, 16, 32, 128, 147, 149, 220, 221, 255, 221, 0, 1];
-    bench.iter(|| a.select(Axis(0), &selectable));
+    c.bench_function("select_axis0", |b| {
+        b.iter(|| black_box(&a).select(Axis(0), black_box(&selectable)))
+    });
 }
 
-#[bench]
-fn select_axis1(bench: &mut Bencher)
-{
+fn select_axis1(c: &mut Criterion) {
     let a = Array::<f32, _>::zeros((256, 256));
     let selectable = vec![0, 1, 2, 0, 1, 3, 0, 4, 16, 32, 128, 147, 149, 220, 221, 255, 221, 0, 1];
-    bench.iter(|| a.select(Axis(1), &selectable));
+    c.bench_function("select_axis1", |b| {
+        b.iter(|| black_box(&a).select(Axis(1), black_box(&selectable)))
+    });
 }
 
-#[bench]
-fn select_1d(bench: &mut Bencher)
-{
+fn select_1d(c: &mut Criterion) {
     let a = Array::<f32, _>::zeros(1024);
     let mut selectable = (0..a.len()).step_by(17).collect::<Vec<_>>();
     selectable.extend(selectable.clone().iter().rev());
-
-    bench.iter(|| a.select(Axis(0), &selectable));
+    c.bench_function("select_1d", |b| {
+        b.iter(|| black_box(&a).select(Axis(0), black_box(&selectable)))
+    });
 }
+
+criterion_group!(benches, select_axis0, select_axis1, select_1d);
+criterion_main!(benches);