Add line-anchor tracking to CodeMirror - #5988

- JS: await editorPromise in setLineAnchors/clearLineAnchors so calls made
  during page setup don't race the editor mount (matches getLanguages /
  getThemes pattern).
- Python: validate input in set_line_anchors (raise ValueError on line < 1
  or duplicate ids) so the mirror cannot diverge from the JS-side clamp.
- Python: harden _update_anchor_mirror against malformed event payloads.
- Demo: subscribe to anchor-positions for live label refresh instead of a
  manual button.
- JS: reset _anchorTimer inside the timeout callback; comment AnchorValue.eq.
- Tests: add coverage for input validation; loosen the bounded-emissions
  threshold so the test stays green on slower CI (the assertion still
  proves coalescing).

The previous implementation had two writers into `_anchor_positions`:
`set_line_anchors` / `clear_line_anchors` wrote synchronously, and
`_update_anchor_mirror` wrote on every JS event. This created three
related bugs:

- a stale debounce closure could resurrect cleared anchors when its
  pre-clear field snapshot fired after `clear_line_anchors`
- `clearLineAnchors` did not cancel the pending JS timer
- the Python mirror diverged from JS for `line > doc.lines`, since JS
  silently clamps and Python stored the un-clamped caller value

Treat the browser as the source of truth instead. JS owns the
`StateField<RangeSet<AnchorValue>>` and emits a full snapshot of all sets
after `setLineAnchors`, after `clearLineAnchors`, and on debounced
`docChanged` updates. The fire-time emit reads live editor state, so any
surviving stale timer sees the up-to-date field. The Python methods
validate input (single pass) and dispatch — `_update_anchor_mirror` is
the only writer, replacing `_anchor_positions` wholesale from each
snapshot.

Tests now wait for the JS round-trip via `screen.wait_for(...)` and a
new `test_clear_after_typing_does_not_resurrect_anchors` locks in the
race fix. Documentation demo subscribes to `anchor-positions` before
calling `set_line_anchors` so the label populates from the first JS
emit.

- JS: warn on clamp in setLineAnchors so callers can see when an
  out-of-range line is silently coerced to the last line, instead of
  the mirror differing from the request with no signal.
- JS: cancel the debounce timer inside setLineAnchors for symmetry with
  clearLineAnchors. Without this, a doc-edit-then-set sequence emits
  twice in close succession (the explicit emit, then the leftover
  debounced emit ~50 ms later) — both idempotent, but chatty.
- JS: drop the dead `if (self._anchorTimer)` guard on clearTimeout.
- Python: log a warning on malformed anchor-positions payloads in
  _update_anchor_mirror instead of silently swallowing them.
- Python: clarify in the set_line_anchors docstring that out-of-range
  lines clamp to the last line, log a console.warn, and that
  line_anchor_positions is authoritative for the actual landed line.
- Tests: replace the fixed `screen.wait(0.3)` after `screen.open('/')`
  with a deterministic `screen.wait_for(...)` that polls for the
  `.cm-content` mount marker. The negative-assertion sleeps in
  test_clear_after_typing_does_not_resurrect_anchors and
  test_anchor_emissions_bounded_during_typing are kept — fixed waits
  are correct for "confirm nothing arrives within a window".
- Tests: rewrite test_anchor_emissions_bounded_during_typing to dispatch
  the 10 doc changes synchronously from JS instead of via Selenium
  send_keys. The previous version was flaky on slower hardware where
  send_keys cadence exceeded the 50 ms debounce, producing one emission
  per keystroke and tripping the threshold. The synchronous dispatch
  guarantees all changes land inside one debounce window, so coalescing
  is observable as exactly one emission.

Anchors are most useful for "did anything that matters change?" — pure
whitespace edits leave anchor positions intact. The previous demo only
echoed the position dict; the new one shows the practical payoff: a
status label that flips green/red depending on whether the user's edits
actually moved the anchored landmarks.

The previous demo just compared anchor positions to initial positions and
flipped a status label red when anchors moved — but anchors *moving* is
exactly what they're supposed to do under whitespace edits, so the green/red
framing inverted the message. The new demo mirrors waldo-commander's actual
usage: anchor robot move targets, show their live line numbers as the user
edits, and provide buttons that rewrite a target's *current* line in place.
That demonstrates the value: address a line by its logical identity, not its
line number, even after the user has reformatted the code.

The line-anchor API targets the 3.14.0 release; only line_tooltips (already on
main) is 3.13.0. Split line anchors into their own *Since version 3.14.0* block
and bump the line_anchors/on_anchor_change/line_anchor_positions markers, leaving
line_tooltips at 3.13.0.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

# Conflicts:
#	website/documentation/content/codemirror_documentation.py

applyLineAnchors dispatched the anchor effect (which re-arms the
tracker's debounce timer) and then emitted immediately, so every
deliberate assignment produced a duplicate emission ~50ms later.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

- fix version markers: line anchors land in 3.16.0, not 3.14.0
  (incl. moving the docstring section out of the 3.14.0 block)
- fix demo description: the button is called "Increment"
- drop useless `deep: true` from the lineAnchors watcher
- name the debounce constant (ANCHOR_DEBOUNCE_MS)
- remove dead `_anchorTimer = null` bookkeeping
- use screen.wait_for_js instead of a raw WebDriverWait
- reword an assert message to state the expectation
- one sentence per line in the mixin docstring

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

The prop held the *declared* lines while only `_anchor_positions` tracked the live
ones, so any re-render re-applied stale positions: switching away from a
tab_panels(keep_alive=False) panel and back snapped every anchor to where it was
declared, and the server mirror silently followed.

The browser-reported snapshot is now mirrored into the prop (via suspend_updates,
so it does not echo back), and beforeUnmount stores the live positions client-side
just like the editor value. A remount therefore restores where the anchors are, not
where they started.

This also replaces the one-shot `_apply_anchors` flag, which `_to_dict` consumed as
a side effect and which relied on exactly one outgoing serialization per assignment:
`_anchors_pending` is set by the setter and cleared when the browser confirms, so
`_to_dict` stays a pure serializer and a lost update heals on the next one.

- keep the prop unset until anchors are declared, so anchor-free editors pay nothing
- return the positions dict raw, like the neighboring line_tooltips getter

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

The tracker scheduled its debounced emit on every document change while any anchor
existed, so typing anywhere — even below every anchor — pushed an identical mapping
to the server once per debounce window and invoked every on_anchor_change handler
with unchanged values, contradicting the documented "whenever tracked anchor
positions change".

emitAnchorPositions now skips the emit when the mapping equals the last one sent.
A deliberate apply still forces it, because the server treats that emit as the
confirmation that its declared anchors have landed — which has to arrive even when
they happen to sit where the live ones already were.

The emission test moved to the public on_anchor_change API and to edits that really
move the anchors, so it pins the coalescing it is named after instead of the
emit-on-unchanged behaviour; the new sibling test covers edits that move nothing.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

test_line_anchors_populates_mirror asserted exactly what the first two lines of
test_line_anchors_replace_and_clear already cover, so it is gone.

test_clear_after_typing_does_not_resurrect_anchors never reached the race it
described: the explicit clear only arrives in the browser after the 50 ms debounce
has already fired, so no stale timer is ever pending when it lands. Injecting the
full bug — a surviving timer that carries its scheduling-time snapshot — left the
test green; it only turned red once the debounce was stretched to 150 ms. What it
was meant to guard is carried by the timer callback reading live editor state
anyway, so the test is dropped rather than rebuilt around a deterministic race.

The remaining remapping cases share the shape "declare anchors, dispatch one
change, check the resulting mirror" and are now one parametrized test, extended
with a deletion above the anchor.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

An anchor declared beyond the end of the document was moved to the last line, and
one below line 1 to the first, each with a browser-side warning. That invented a
position nobody asked for: declaring line 50 in a three-line document read back as
line 3, which looks plausible and is wrong, while the warning surfaced far away from
the assignment. The neighbouring line_tooltips already handles the same situation by
dropping the entry, so two adjacent APIs of one element disagreed.

Anchors outside the document are now dropped with a warning, like tooltips, so a
read never reports a position that was not applied — a dropped anchor is visible as
a missing key. A line below 1 needs no knowledge of the document to be recognised as
wrong, so it is rejected at assignment time with a ValueError that points at the
caller instead of appearing asynchronously in the browser log.

Both entry points validate before they touch anything: the setter before it changes
state, and the constructor before super().__init__ registers the element — otherwise
a rejected argument left a half-built editor sitting in the element tree, without a
language, a theme or its event listener.

The feature is unreleased, so this needs no deprecation path.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Five of the demo's seven lines were string surgery — split, index, parse, rewrite,
join — around a feature that is a single expression: reading line_anchors gives you
a line number. Worse, the description invited the reader to "edit the code freely",
which broke the demo: changing the anchored line to anything not ending in a number
made int() raise inside the click handler, so the button silently stopped working.

The demo now declares an anchor and binds a label to it. Inserting lines above the
anchored one moves the reported number, which is the whole point, and nothing in it
can fail. The description also drops the RST double backticks it had picked up;
demo texts are rendered as Markdown.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>