docs(README): trim noisy intro + use-case + architecture prose

[dpsoft]

Iteration on the README that lands now that #15 is in. Three passages were doing more work than they earned; this PR trims them.

Changes

1. Intro paragraph

Mixed pitch with implementation detail across two paragraphs. Now one sentence.

```diff

• A single binary that samples on-CPU stack traces, off-CPU blocking time, and hardware PMU
• counters — and emits production-ready pprof. Hybrid FP+DWARF unwinder handles release-built
• C++/Rust binaries that omit frame pointers; built-in symbolization for native code (DWARF +
• ELF), Python (`-X perf` perf-maps), Node.js (`--perf-basic-prof`), and Go.
• Runs entirely local. No backend, no telemetry, no scrape config.

• Capture on-CPU, off-CPU, and PMU profiles — system-wide or per-PID — and emit pprof. One
• binary, runs locally, no backend or telemetry.
  ```

The dropped tech detail (FP+DWARF, Python `-X perf`, Node.js `--perf-basic-prof`) still lives in the use-case section and Flags table — readers who want to know how find it; readers who want to know what aren't ambushed with it.

2. `--inject-python` use case

Four-clause sentence covering trampoline semantics, sidecar deployment, `shareProcessNamespace`, and `kubectl cp`. The deployment shape duplicates the 🐳 Sidecar profiling inside Kubernetes pods use case lower down. Trim to the actual value prop.

```diff

• Hot-attach to a running pod or process — no restart. For Python 3.12+, `--inject-python`
• activates the perf trampoline at profile start and deactivates it at exit, so the per-call
• overhead does not persist past the profiling window. Drop in as a sidecar
• (`shareProcessNamespace: true`), capture for 30s, exit. Output is pprof; ship it home with
• `kubectl cp` or pipe it into your store.

• Hot-attach to a running process — no restart, no preinstalled agent. For Python 3.12+,
• `--inject-python` enables the perf trampoline only for the capture window, so there's no
• persistent overhead.
  ```

3. Architecture prose

Compressed two dense paragraphs (MMAP2 watchers, eager-compile fallbacks, ehcompile→ehmaps installation, per-PID lazy caching) into two sentences. The architecture diagram stays; the prose around it now states which flag selects which walker, and what `procmap.Resolver` buys downstream tools.

```diff

• Two stack-walker paths share a single user-space pipeline:
• • FP path (`--unwind fp`): cheap, kernel-side stackmap aggregation. Truncates on
• FP-less code (release C++/Rust without `-fno-omit-frame-pointer`).
• • DWARF/hybrid path (`--unwind dwarf` or `auto`, the default): pure-FP for FP-safe
• code, falls through to `.eh_frame`-derived CFI rules for FP-less PCs. Userspace
• pre-compiles per-binary CFI from `.eh_frame` (`unwind/ehcompile`) and installs it into
• BPF maps (`unwind/ehmaps`); the BPF walker reads CFI per-frame. MMAP2 events keep CFI
• fresh as processes `dlopen`/`exec`. Eager-compile failures (Go binaries lack
• `.eh_frame`) are tolerated — the walker's FP path covers those.
• The `procmap.Resolver` sits between the walkers and pprof. It lazily reads
• `/proc//maps` and ELF `.note.gnu.build-id`, caches per-PID, and gives the pprof
• builder real `Mapping` identity (path, start/limit, file offset, build-id). Each
• `Location` is keyed by `(mapping_id, file_offset)` rather than by symbol name, so two
• PCs that symbolize to the same `(file, line, func)` stay distinguishable — the data
• downstream tools need for sample-based PGO and cross-run diffing.

• Two stack-walker paths: `--unwind fp` (cheap, kernel-side aggregation; truncates on
• FP-less code) and `--unwind dwarf` / `auto` (default — FP fast path with
• `.eh_frame`-derived CFI fallback for release C++/Rust without frame pointers).
• Sample addresses resolve through `procmap.Resolver` (lazy `/proc//maps` +
• build-id), so each pprof `Mapping` carries real per-binary identity and each `Location`
• is keyed by `(mapping_id, file_offset)` — what `go tool pprof -diff_base` and
• sample-based PGO converters need to round-trip.
  ```

No new files, no link-outs. Readers who want depth open the code.

Diff shape

```
README.md +4 / −9 (439 → 434 lines)
```

Status

Draft. Iterating — happy to keep cutting if you point at more passages that don't earn their keep.