Brings the Rust integration test suite into line with the C suite's
"malloc only where strictly necessary" model. Three classes of change,
applied uniformly to both tests/det.rs and tests/nondet.rs:

1. Unroll the two deeply-nested fixtures with a local macro_rules!
   instead of looping with a per-iteration `Box::leak`.

   `arr_deeply_nested_canonical` (DEPTH=30) and `map_deeply_nested_canonical`
   (DEPTH=10) used to walk a `for _ in 0..DEPTH` loop, each iteration
   leaking a one-element slice to satisfy the constructor signature
   `cbor_*_mk_array<'a>(&'a [CborDet<'a>])` (which forces every level's
   storage to outlive the returned value). The new `arr_wrap!` /
   `map_wrap!` macros consume one `()` token per level and emit one
   fresh `let items = [current]; let current = mk(&items).unwrap();`
   pair per token. Macro hygiene gives every expansion its own distinct
   `items` binding, so the N intermediate stack arrays nest naturally
   in lifetime (`'i1 ⊇ … ⊇ 'iN`) — structurally analogous to the C
   suite's single stack buffer `cbor_t levels[31]`.

   Const generics alone can't do this: Rust has no syntax for
   parameterising the *number of distinct lifetimes* in a signature;
   the macro is the smallest construct that supplies N independent
   lifetime quantifiers driven by a compile-time constant.

2. Convert 14 single-scope `leak_arr` / `leak_entries` call sites to
   stack-local arrays. These never needed heap promotion in the first
   place — the original author defaulted to the leak helper everywhere
   even when one enclosing function scope could already hold the
   backing storage. Affected tests:

     - map_empty_canonical:           1 site
     - arr_empties_canonical:         3 sites (three independent empty
                                      maps; each needs its own `&mut`
                                      backing array because mk_map's
                                      returned value formally borrows
                                      the slice)
     - map_nested_keys_canonical:     2 sites (pair1, pair2)
     - tag_array_payload_canonical:   1 site

   Empty-entry arrays are annotated as `[CborDetMapEntry<'_>; 0]` so
   Rust infers the lifetime per call. Non-empty arrays infer everything.

3. Convert two `Box::leak(Box::new(...))` chains in
   `tag_nested_canonical` to three stack locals. Works because
   `CborDet<'a>` is covariant in `'a`, so the chain
   `'leaf ⊇ 'mid ⊇ 'expected` typechecks naturally; one
   coupled `Box::leak` in tag_array_payload_canonical is removed
   on the same grounds.

Remaining heap leaks (kept as strictly necessary):

  - arr_2200_deep_canonical (det+nondet) — 2200-deep loop;
    unrolling would emit 2200 lines per test.
  - dnm recursive helper inside map_nested_keys_canonical (det+nondet)
    — returns `CborDet<'static>` from a recursive function; eliminating
    requires CPS or an arena.

The leak_arr / leak_entries helper definitions stay in both files
(still used by the four sites above); no dead-code warnings.

Verified: full Rust test suite (352 det + 352 nondet = 704 tests)
passes with `cargo test --release` against the existing C-emitted
artefacts in share/everparse/tests/cbor/out/. No new warnings.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>