fix: avoid O(N²) per-chunk reprocessing in long-running StreamingSession

[rubdttcom]

Problem

StreamingSession rebuilds the running transcript and the word grouping from
the entire session history on every chunk:

• process_emitted() runs detokenize() over all non-special tokens so far.
• regroup_words() runs group_words() over all accumulated word tokens.

Neither buffer is trimmed across utterances (the <EOU>/<EOB> reset only
clears the decoder LSTM state). So for a long-lived stream the per-chunk cost
grows with the whole session — O(N²) total CPU — and the repeated growing
allocations make RSS climb. A dictation session left open for hours pegs a core;
a multi-minute continuous stream already shows the per-chunk rate collapsing.

Fix

Make both steps incremental, with identical output:

• Text: detokenize is prefix-stable (per-token piece concat + ▁→space,
  and the single leading-space strip only touches byte 0). So append only the
  newly emitted tokens' text to text_ instead of rebuilding it each chunk.
• Words: re-group only the still-open tail (word_tokens_ from the last
  ▁-word-start) and keep already-finalized words. group_words splits at
  ▁-word-starts and its only cross-token effects (one-token forward lookahead,
  backward punctuation attach) never cross a word-start boundary, so
  group_words([0,cursor)) ++ group_words([cursor,end)) == group_words([0,end)).

No public contract changes: text(), tokens(), take_new_text(),
drain_words(), drain_events() return exactly what they did before — now O(1)
amortized per chunk instead of O(N).

Testing

• New tests/test_streaming_longrun_bounded.cpp drives a long multi-utterance
  stream and asserts (a) the worst single-chunk reprocessing stays bounded (does
  not scale with the session) via a lightweight high-water counter, and (b) the
  incremental text() is byte-for-byte identical to a full detokenize() of all
  non-special tokens (public API). Measured on the streaming nemotron model:
  max_chunk_reprocess 3202 → 20 over a 1601-token session.
• Existing streaming parity tests stay green against the NeMo reference
  (test_streaming_decode, test_streaming_eou_reset, test_streaming_encoder,
  test_streaming_nemotron, test_capi_stream_json) — these cover the word
  grouping output.

Skips cleanly (exit 77) without PARAKEET_TEST_GGUF_STREAM, matching the other
model-dependent tests.