W0110 inline fallback warning + docs refresh

W0110: when a function marked `inline` has a body shape the IR
lowerer can't splice (conditional early return, loops, nested
control flow, empty void body), the analyzer now emits a
warning at the declaration site so the declined hint is
visible instead of silently falling back to a regular JSR.

Implementation:
  - New `W0110` error code in `src/errors/diagnostic.rs` (warning level).
  - New `pub fn can_inline_fun(return_type, body) -> bool` in
    `src/ir/lowering.rs`, extracted from the existing capture
    logic so the analyzer and the IR lowerer share the same
    eligibility rules and can never drift.
  - New `check_inline_declinability` analyzer pass called from
    the tail of `analyze_program`, mirroring the existing
    `check_sprite_scanline_budget` / `check_unreachable_states`
    passes. Emits W0110 with help + note text pointing at the
    two accepted body shapes.
  - `capture_inline_bodies` now defers to `can_inline_fun`
    instead of duplicating the match pattern, so the two sides
    stay in lockstep by construction.

Four regression tests in `src/analyzer/tests.rs` cover the
conditional-return and while-loop declines plus the two
accepted shapes (single-return expression, void sequence).

Example source cleanups: `wrap52` in `examples/war/deck.ne`
and `abs_diff` in both `examples/arrays_and_functions.ne` and
`examples/loop_break_continue.ne` drop the `inline` keyword.
All three were dead hints — the `inline` was being silently
declined before this change, so removing it is source-only;
the three ROMs are byte-identical, all 32 emulator goldens
still match.

Docs refresh
  - `docs/language-guide.md`: rewrote the Inline Functions section
    (real behaviour + W0110), added W0105/W0106/W0107/W0108/W0109/
    W0110 to the warnings table, added the `debug.sprite_overflow*`
    builtins + sprite-per-scanline mitigations section to the
    Debug Mode docs, added a `cycle_sprites` statement entry and
    cross-referenced it from `draw`.
  - `docs/nes-reference.md`: fleshed out the "NEScript Memory
    Usage" block with the full ZP + high-RAM layout, including
    the new `$07EF` / `$07FC` / `$07FD` slots for sprite cycling
    and the debug sprite-overflow telemetry.
  - `docs/future-work.md`: documented all four debug query
    builtins in the "What ships today" block; updated the open
    "OAM allocation strategy" question to reference the shipped
    `cycle_sprites` path and ask about an automatic-flicker
    game attribute as a follow-up.
  - `docs/architecture.md`: updated the `ir/` and `optimizer/`
    module summaries to describe real inline splicing (now
    in lowering, not the optimizer).
  - `README.md`: reframed the `inline` bullet from "hint" to
    "real splicing for single-return / void-body shapes";
    expanded the debug-support bullet to mention the four
    query builtins and their stripping in release builds; added
    a new bullet for the three-layer sprite-per-scanline
    mitigations; bumped the test count from 497 → 694; updated
    the war.ne entry to mention the seven compiler bugs are all
    fixed and point readers at `git log` (instead of the
    deleted COMPILER_BUGS.md).
  - `examples/README.md`: same `git log`-pointing rewrite for
    the war.ne entry.

Deletions
  - `examples/war/COMPILER_BUGS.md` is removed. All seven
    catalogued bugs are fixed; the file's historical value
    lives in `git log` now. Every source-code comment and doc
    reference to the file has been updated to either point at
    `git log` or just describe the bug in place.

Test count: 616 unit + 75 integration + 3 doctests = 694 total.
Clippy / fmt clean. 32/32 emulator goldens match.

https://claude.ai/code/session_0143dTgh3UeRrtfHgQwzcv5z

docs/future-work.md

@@ -151,11 +151,16 @@ op and writes a plain-text map of `<rom_offset> <file_id> <line> <col>`
 entries for every lowered statement. Debug builds emit array bounds checks
 (CMP against size, BCC past a `JMP __debug_halt` wedge) and bump an
 overrun counter at `$07FF` in the NMI handler when the main loop didn't
-reach `wait_frame` before the next vblank. **Plus** two new query
-expressions: `debug.frame_overrun_count()` returns the cumulative counter
-and `debug.frame_overran()` returns a per-frame sticky bit (cleared by
-the next `wait_frame`) so user code can write
-`debug.assert(not debug.frame_overran())` guards.
+reach `wait_frame` before the next vblank.
+
+**Plus four query expressions** that mirror the counter/sticky pattern:
+`debug.frame_overrun_count()` / `debug.frame_overran()` return the cumulative
+overrun counter and a per-frame sticky bit so user code can write
+`debug.assert(not debug.frame_overran())` guards, and
+`debug.sprite_overflow_count()` / `debug.sprite_overflow()` do the same for
+the NES PPU's sprite-per-scanline flag (`$2002` bit 5), which the NMI
+handler samples once per frame in debug mode. All four sticky bits clear
+on the next `wait_frame`.
 
 **Still TODO.**
 - **`debug.overlay(x, y, text)`** — needs the text/HUD subsystem (see
@@ -204,8 +209,13 @@ semantics come back, add the codes at that point.
    would be cheap but would invalidate any copy-pasted ca65 fragments.
 2. **Debug port address.** $4800 is conventional but not universal. Should
    we support multiple debug output methods?
-3. **OAM allocation strategy.** Sequential allocation vs priority-based with
-   automatic sprite cycling for the 8-per-scanline limit?
+3. **OAM allocation strategy.** Sequential allocation remains the default;
+   the `cycle_sprites` opt-in keyword rotates the DMA offset each frame so
+   scenes past the 8-per-scanline budget flicker instead of dropping the
+   same sprite every frame. Open question: should automatic cycling become
+   a `game` attribute (`sprite_flicker: true`) that emits the increment
+   without requiring a per-frame call, and/or add a `draw ... priority:
+   pinned` modifier for HUD sprites that must stay at low OAM slots?
 4. **Error recovery granularity.** How aggressively should the parser
    recover? More recovery means more errors per compile but also risks
    cascading false errors.