Swap ownership, fsync race, RowsView memory, renderer regex stack

- A session never unlinks a journal it does not own: Detach, ResetJournal
  and NotifyFilenameChanged skip removal when this session was locked
  out or another session holds the lock, and PruneSwapDir skips held
  journals. A second session used to delete the first session's live
  journal on save or close.
- The writer thread's periodic fsync now runs under mtx_. It fsynced fds
  that the main thread could close concurrently (or that had been
  reused); an in-flight fsync also kept a just-closed journal's flock
  alive, so the owner's own cleanup saw its journal as held.
- Compaction locks the compacted file before renaming it into place and
  keeps using it, so the journal is never unlocked in between; a failed
  lock on the truncating reopen marks the session locked out.
- Unnamed-buffer journals include the pid, so sessions no longer share
  (and delete) each other's unnamed-N.swp.
- RowsView keeps only the previous generation of cached rows: keeping
  all of them made C-u 2000 M-d on a 1 MiB line use ~2 GB.
- Renderers run regex match highlighting through ForEachRegexMatch,
  which uses the large-stack worker for lines over 512 bytes; some
  patterns overflowed the main stack well under the previous 10,000
  byte limit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015rcVQiiWyTzoNrsvLSaAfB

RegexGuard.h

@@ -8,15 +8,24 @@
 
 #include <cstddef>
 #include <functional>
+#include <regex>
+#include <string>
 
 namespace kte {
-// Renderers highlight regex matches only on lines up to this many bytes;
-// longer lines are drawn without match highlighting.
-constexpr std::size_t kRegexRenderLineLimit = 10000;
+// Renderers highlight regex matches only on lines up to this many bytes (to
+// bound per-frame work); longer lines are drawn without match highlighting.
+constexpr std::size_t kRegexRenderLineLimit = 1000000;
 
 // Run fn to completion on a thread with a large stack (address space is
 // reserved, pages are committed only as used), so regex work over long lines
 // cannot overflow. If such a thread cannot be created, fn runs on the calling
 // thread. Exceptions thrown by fn are rethrown to the caller.
 void RunWithLargeStack(const std::function<void()> &fn);
+
+// Call on_match(position, length) for each match of rx in line. Lines short
+// enough to be safe on any stack are matched inline; longer ones on a large
+// stack (a 10,000-byte line already overflowed 8 MiB for some patterns).
+// Throws what std::regex throws.
+void ForEachRegexMatch(const std::string &line, const std::regex &rx,
+                       const std::function<void(std::size_t, std::size_t)> &on_match);
 } // namespace kte