Compress a BiCV trial's held-out split once, reused across every rank

[aarmey]

Summary

Stacked on #556 (this branch is based on it and should merge after it).

bicv() previously called run_parafac2 once per (rank, repeat) pair,
and run_parafac2 unconditionally recompressed its input via
compress_dataset whenever compression_kwarg was given — so a
100-rank x 3-repeat sweep ran ~300 full CANDELINC compressions of
freshly-split raw data, each an O(nnz) pass over the (train-block) data.

This was unnecessary: CompressedData is explicitly designed to support
fitting any rank <= L_g/L_c ("enabling fast rank sweeps without
touching the raw data again" — its own docstring), and parafac2_nd
already accepts a precomputed CompressedData directly. A BiCV trial's
train/test split is independent of rank (only the downstream PARAFAC2 fit
depends on rank), and the in-sample fit's full dataset doesn't change
across ranks either — so both paths were recompressing the same data at
every rank for no reason.

Changes

• _fit_at_ranks(X_in, ranks, ...): when compression_kwarg is given,
  compresses X_in exactly once via compress_dataset, sized for
  max(ranks) (via compress_dataset's own rank parameter, which sets
  the compression dimensions for the largest rank you intend to fit), then
  calls parafac2_nd(compressed, rank=r) directly for every r in
  ranks, reusing that one compressed representation. Without
  compression_kwarg, behavior is unchanged: each rank still goes through
  run_parafac2's own per-call internal compression shortcut, since there
  is no CompressedData object to hoist out of that path.
• _bicv_trial now takes ranks: Sequence[int] instead of a single
  rank, and returns one result dict per rank — computing the
  once-per-trial split and its rank-independent downstream references
  (test-block moments, restricted train/test views) exactly once and
  reusing them for every rank's held-out scoring, rather than
  recomputing per rank.
• bicv()'s main loop restructures to match: one held-out split per
  repeat, evaluated at every rank, instead of one independent split per
  (rank, repeat) pair. Same for the in-sample fit: the full dataset is
  compressed once (sized for the largest rank) and reused across ranks.

Test plan

• uv run pytest scrise/tests/ — 133 passed, 1 skipped (pre-existing,
  unrelated)
• uv run ruff check . / uv run ruff format --check .
• uv run ty check scrise/
• New tests: compress_dataset is called exactly 1 + n_repeats
  times for an n-rank sweep (not n * (1 + n_repeats)), each call
  sized for the largest requested rank; the compression_kwarg-less
  path is unaffected (still one run_parafac2 call per (rank, repeat) pair, as before).
• All existing correctness tests pass unchanged, including the
  dense-reference comparison tests (test_streamed_scoring_matches_*)
  and the seed-reproducibility test, confirming the single-rank,
  no-compression_kwarg code path is bit-for-bit unaffected.

Related

• Replace chunked-transpose matmul fallback with a native minor-axis kernel vsparse#49, Add select(recalculate=False): a lazy, stats-preserving row/col selection vsparse#50, Keep BiCV's held-out cell blocks lazy for duck-typed backends #556 (the memory-safety work
  this builds on)