[docs] Trim the streaming-truncation changelog

Tighten the entry to two short paragraphs: a one-line summary of the
change, the micro vs realistic-suite numbers side by side, and the
user-visible footer / per-line reset side-effects. Drops the
implementation walk-through that earlier drafts carried.

Author: Pierre-Sassoulas

changelog/14523.improvement.rst

@@ -1,35 +1,13 @@
-The assertion comparison helpers and the truncator now hand the
-explanation between them as an iterator, so the dispatcher only has to
-materialise lines the truncator actually keeps. For the typical small
-diff this is a no-op; for the rare case where two large collections
-fail to compare, peak memory drops by a few percent because the
-millions of lines that would have been built and immediately discarded
-are no longer built.
+Assertion explanations are now built lazily and the truncator stops
+the comparison helpers as soon as it has enough output, so comparing
+two large collections no longer builds the full diff in order to
+discard it. A focused micro-benchmark the worst case scenario
+(``set(range(500_000)) == set(range(1, 500_001))``) drops from ~2,200 ms
+to ~43 ms; but realistic test suite with mostly small diffs should be
+unchanged.
 
-The truncation footer no longer reports the exact number of hidden
-lines: ``...Full output truncated (N lines hidden), use '-vv' to
-show`` is now ``...Full output truncated, use '-vv' to show``.
-Dropping the count means the streaming truncator can return as soon
-as it has reached the budget, without draining the rest of the
-iterator just to count what it discarded.
-
-The "Full diff:" block for large iterables now passes each
-``difflib.ndiff`` line through the syntax highlighter individually
-instead of joining the full diff first. The streaming truncator can
-stop ``difflib.ndiff`` as soon as its budget is filled. As a
-side-effect, each diff line now starts with a redundant ``\x1b[0m``
-reset (invisible to the terminal).
-
-When the truncator is going to be active (``verbose < 2`` outside
-CI), ``_compare_eq_iterable`` now caps ``PrettyPrinter`` output at
-the truncator's ``truncation_limit_lines`` budget (plus 3 lines —
-matching the truncator's own ``line_cap``: 2 lines for the truncation
-message it appends + 1 for overshoot detection) via a budget-aware
-stream that raises out of the formatter
-once it has emitted enough lines. Combined with a fast path for
-sorted set comparisons (try the natural ordering first, fall back to
-the ``_safe_key`` wrap only on ``TypeError``), this turns the diff
-for a 500,000-element set comparison from ~2,200 ms down to ~43 ms
-(~50× speedup) while leaving the visible output identical for the
-truncated display. ``-vv`` and CI runs still get the full uncapped
-diff.
+The truncation footer no longer reports the hidden-line count
+(``...Full output truncated (N lines hidden), ...`` becomes
+``...Full output truncated, ...``); diff lines now carry a redundant
+``\x1b[0m`` reset prefix (invisible to terminals) so we can handle
+line one by one.