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.cc

@@ -48,4 +48,22 @@ RunWithLargeStack(const std::function<void()> &fn)
 	if (job.error)
 		std::rethrow_exception(job.error);
 }
+
+
+void
+ForEachRegexMatch(const std::string &line, const std::regex &rx,
+                  const std::function<void(std::size_t, std::size_t)> &on_match)
+{
+	auto scan = [&] {
+		for (auto it = std::sregex_iterator(line.begin(), line.end(), rx); it != std::sregex_iterator(); ++it)
+			on_match(static_cast<std::size_t>(it->position()), static_cast<std::size_t>(it->length()));
+	};
+	// Stack use grows with match length; a few hundred bytes stays far below
+	// any thread's stack for every pattern we measured.
+	constexpr std::size_t kInlineLimit = 512;
+	if (line.size() <= kInlineLimit)
+		scan();
+	else
+		RunWithLargeStack(scan);
+}
 } // namespace kte