## Summary

Fixes #5896. When devtools is enabled, rolldown's wall time collapses to I/O-lock wait time. This PR moves devtools log I/O onto a dedicated background thread, removing the per-event cross-thread lock and the blocking file writes from the hot path.

### Benchmark — `vite v8.0.10` + `@vitejs/devtools`, 1,404-module antd + React app (#5896 reproduction)

| build                          | time         |
|--------------------------------|--------------|
| main                           | **27.98 s**  |
| this PR (04-24-perf_devtools)  | **522 ms**   |
| **speedup**                    | **~54x**     |

## Root cause

`DevtoolsFormatter::format_event` ran on every `trace_action!`-emitted event — i.e. on every `resolve_id` / `load` / `transform` / `render_chunk` plugin hook, across every plugin. For one build session this is easily tens of thousands of events, fired from every tokio worker in parallel.

Before this PR, the formatter did all of this synchronously on the caller:

1. `OPENED_FILE_HANDLES.get_mut(&log_filename)` (a `DashMap<Arc<str>, File>`), which takes a **per-shard `parking_lot::RwLock` write guard**.
2. Held that guard across two full JSON-serialization passes (one for StringRef dedupe, one for the event line), the `WriteFile` syscall(s), and `file.flush()`.
3. Every session funnels all events into the same filename (`node_modules/.rolldown/<session>/logs.json`) → same DashMap key → same shard → **one lock serializing every tokio worker**.

The ETW profile made this unambiguous: with devtools on, **83% of all samples landed at `ntdll!NtWaitForAlertByThreadId`**, **99% of total thread time in `format_event` was in System Libraries** (parking in `parking_lot` via `WaitOnAddress`), and only **~1.2% of samples were actually executing Rust**. The call path was always

\`\`\`
NtWaitForAlertByThreadId -> WaitOnAddress -> parking_lot::park ->
  parking_lot::RawRwLock::lock_exclusive_slow ->
  dashmap::DashMap::_yield_write_shared ->
  dashmap::DashMap::get_mut ->
  rolldown_devtools::devtools_formatter::impl\$1::format_event
\`\`\`

So the slowdown wasn't \"more work\" — the actual Rust CPU work only grew ~5x. It was **cross-thread lock contention** serializing all worker threads onto one I/O-holding RwLock.

## Fix

Move all log I/O to a single dedicated `rolldown-devtools-writer` thread. Producers (the tokio workers running plugin hooks) do a fire-and-forget `Sender::send` over `std::sync::mpsc`:

- New `rolldown_devtools::writer` module owns the channel, the `BufWriter<File>` per log file, the per-session file tracking, and the per-session StringRef-dedupe hash set.
- `DevtoolsFormatter::format_event` now only does the JSON shaping that needs event-local context (placeholder resolution via span extensions, filename selection), then sends `LogCommand::Write { session_id, filename, action_value }` and returns. **No cross-thread lock is taken, no syscall is issued, on the hot path.**
- Removed `OPENED_FILE_HANDLES`, `OPENED_FILES_BY_SESSION`, `EXIST_HASH_BY_SESSION` (and the `dashmap` dep) — all that state now lives on the writer thread where no synchronization is needed.
- Directory creation is memoised per-session on the writer (`dir_ensured` set), instead of a `create_dir_all` syscall per event.
- `BufWriter` batches small `serde_json` writes into ~8 KB chunks, cutting `WriteFile` syscall count dramatically compared to the previous `serde_json::Serializer::new(&mut file)` -> raw `File` path.

### Read-after-close contract

Because log I/O is now asynchronous and buffered, consumers reading `meta.json` / `logs.json` immediately after `generate()` / `write()` could see truncated content. To preserve the expectation that **the log files are readable and complete once `await bundle.close()` resolves**, `ClassicBundler::close()` now:

1. Snapshots whether devtools is active (`self.debug_tracer.is_some()`).
2. Calls `rolldown_devtools::flush_session(session_id)`, which sends `LogCommand::CloseSession { session_id, ack: Some(tx) }` and returns the corresponding `Receiver<()>`.
3. `spawn_blocking`s `rx.recv_timeout(30s)` so a stalled fs (e.g. NFS disconnect) can't wedge `close()` indefinitely, and surfaces timeout / disconnect as errors rather than silently truncating logs.

`DebugTracer::Drop` still sends a best-effort no-ack `CloseSession` for the abnormal-exit path; the authoritative flush path is `ClassicBundler::close()`. Documented in `meta/design/devtools.md`.

## Why this is faster

- **No lock contention on the hot path.** Previously N tokio workers serialized on one `parking_lot::RwLock` write guard held across I/O; now they only contend on `std::sync::mpsc`'s sender, which is lock-free-ish and never held across I/O.
- **Producer / writer pipelining.** On main, log I/O was on the critical path of every worker task. Now workers return to doing compile work the moment they hand off the event; the writer thread drains the queue in parallel with them. Total wall time becomes `max(compute, log_drain)` instead of `sum`.
- **Fewer syscalls.** `BufWriter` + per-session cached `create_dir_all` eliminate the per-event `mkdir` syscall and collapse each event's many `write()` calls into one.

This PR is strictly about unblocking the hot path. Other independent wins (lazy `content: Some(code.clone())` in `trace_action!` payloads, single-pass StringRef dedupe, skipping the JSON-string round-trip through `DevtoolsActionFieldExtractor`) are deliberately left for follow-ups — they reduce CPU work, but CPU was never the bottleneck.

## Test plan

- [ ] `cargo test --workspace` green
- [ ] Manual: run an antd build with `devtools: {}`, confirm `node_modules/.rolldown/<sid>/{meta,logs}.json` are well-formed JSON-lines and contain the expected action events
- [ ] Manual: confirm log files are complete after `await bundle.close()` (read file in a Node consumer immediately after close, assert last line parses)
- [ ] Re-record samply profile on the antd repro — verify `format_event` is no longer a hotspot and Rust-leaf sample share recovers