Add two eval-harness knobs so a subset of the LongMemEval set can be run
in isolation instead of the whole dataset:

- LONGMEMEVAL_TYPE: comma-separated question_type allow-list (e.g.
  "temporal-reasoning,multi-session"). Unset = all types. The flat
  LONGMEMEVAL_LIMIT now counts only kept records, so N filtered
  questions run cleanly.
- LONGMEMEVAL_PER_TYPE: stratified slice keeping N records of EACH
  question_type (balanced A/B), since _m/_s are grouped by type on disk
  and a flat limit would only sample the first type.

Harness-only change under eval/; no library code touched.

Two edge cases in the stratified run-limit math:

- A malformed LONGMEMEVAL_TYPE (e.g. only commas/whitespace) produced a
  zero type count, so runLimit=perType*0=0 stopped runEval immediately
  even though loadRecords treated the empty allow-list as "all types" and
  kept emitting a stratified sample - the harness ran no records.
- typeCount counted every raw comma entry, so a repeated type inflated
  runLimit and the banner while loadRecords (Set-keyed allow-list) yields
  at most one stratum per distinct type.

typeCount now derives from a deduped Set of trimmed types (mirroring
loadRecords) and falls back to the full 6 when the selection is empty, so
it is never zero and never double-counts.

Stratified mode (LONGMEMEVAL_PER_TYPE) only early-stopped when an explicit
LONGMEMEVAL_TYPE allow-list was set. With no filter the loader had no notion
of "all types seen" so it scanned the whole file to EOF even after every
per-type cap was full, draining a multi-GB dataset (longmemeval_m ~2.7GB).

Pass the LongMemEval type count (6) as an expectedTypeCount hint so the loader
can early-stop once counts.size >= expectedTypes and every count >= perType,
even with no explicit filter. Two regression tests use a poison-tailed JSON
stream to prove the loader stops before the malformed tail with the hint and
reaches it (throws) without.

Addresses review feedback: the comma-separated question_type parse was
copy-pasted between run.ts (sizing the per-record limit cap) and dataset.ts
(filtering + stratified early-stop). The early-stop math relies on the two
derivations being identical, so a drift in one copy would silently desync
runLimit and the loader's expectedTypes.

- Extract `parseTypeList(value?): Set<string>` in dataset.ts as the single
  source of truth; import it in both run.ts and loadRecords.
- Narrow the per-type cap to a `const cap = perType ?? 0` local, dropping the
  two `perType as number` casts in loadRecords.
- Lock parseTypeList semantics (trim, drop blanks, dedupe, empty=all) with a
  focused test.