A write's LSP check runs on the LSP loop after the tool result returns, and it re-read
the file from disk when it got there. If another session wrote the same file in
between, the first session's check diagnosed the second session's bytes. With the real
typescript-language-server: session A changes `x: number = 1` to `2` (clean), session
B changes it to `"bad"` (TS2322). Both sessions were told about 2322, each attributed
to its own edit. Session-keyed queues stop takeover, but nothing tied the checked
bytes to the session that owned them.
Each check now carries an immutable snapshot of its edit: the pre-edit content (the
baseline, as before) and the post-edit content the write produced. `_check` syncs
the post-edit snapshot for the verdict, so the verdict only covers bytes that session
wrote. Afterwards the server is re-synced to the newest content written to the file
(recorded when the newest check is scheduled), so editor state and the next check's
baseline still follow the disk. Same-session coalescing is unchanged: a newer edit by
the same session still takes over an unfinished check and diffs against its baseline.
Supplied text is normalized the way the disk read decodes it (BOM, CRLF, undecodable
bytes), so a snapshot and its file sync identically and baseline-cache hits survive.
Test: test_each_session_is_checked_on_the_bytes_it_wrote holds the LSP loop, makes
A's clean edit and B's erroneous edit to one file, then releases. A must hear nothing
and B must get its error. Red on 22a383286c (A gets MOCK001), green here.