fix(render): ceil canvas dimensions so 4K full-screen doesn't leak the wrap bg

[winlp4ever]

Problem

On high-DPI displays (notably 4K full-screen), `ResizeObserver` can report fractional CSS widths (e.g. `3840.4`). The previous canvas-sizing math:

```ts
surface.canvas.width = Math.max(1, Math.round(cssW * dpr)) // backing: rounded down
surface.canvas.style.width = `${cssW}px` // CSS: raw fractional
```

…rounded the backing store to integer device pixels but kept the raw fractional value for the CSS dimension. At certain widths/DPRs, the browser snaps that CSS dim down at layout time, leaving the canvas ~0.5 CSS px narrower than the wrap div. The wrap's background (`#f8fafc`, hard-coded in Canvas.tsx, not theme-aware) shows through that thin strip on the right edge.

• Light mode: wrap bg matches the page → invisible.
• Dark mode + 4K full-screen: faint white vertical line on the right, briefly visible during quick zoom-out (each tier-3 frame clears the static surface then repaints, momentarily exposing the strip).

Slightly resizing the window away from 4K-exact makes `cssW` integer-aligned and the gap disappears — which matches what was reported.

Fix

Use `Math.ceil` (not `Math.round`) consistently for backing store, CSS dim, and the stored `surface.cssWidth`/`cssHeight`:

```ts
const ceilCssW = Math.ceil(cssW)
const ceilCssH = Math.ceil(cssH)
surface.canvas.width = Math.max(1, Math.round(ceilCssW * dpr))
surface.canvas.height = Math.max(1, Math.round(ceilCssH * dpr))
surface.canvas.style.width = `${ceilCssW}px`
surface.canvas.style.height = `${ceilCssH}px`
surface.cssWidth = ceilCssW
surface.cssHeight = ceilCssH
```

This guarantees the canvas is always ≥ wrap width, never narrower. Sub-pixel overflow (< 1 CSS px) is clipped invisibly by the wrap's existing `overflow: hidden`.

Side fix

Updates the early-out check in `sizeSurface` to compare against the ceiled values too. Without that, a fractional ResizeObserver report that ceils to the same integer as the cached value would re-allocate the canvas backing store on every call — visible flicker on 4K.

Why the renderer's viewport math also gets the ceiled value

`surface.cssWidth` flows into `worldViewport`, `paintBackground`, and the cache-source-rect helpers. Storing the raw fractional value while displaying the ceiled value would mean the renderer thinks the viewport is one size while the canvas is actually displaying another — sub-pixel discrepancy at the right edge. Storing the ceiled value keeps both halves consistent.

No regressions for the common case

Tests run at integer `cssW` / `cssH` values. `Math.ceil(N)` of an integer is the same integer, so the existing test fixtures behave identically.

Test plan

• `pnpm -w typecheck`
• `pnpm -w lint`
• `pnpm -w test` — 351 + 1 passed
• `pnpm -C packages/core test:browser` — 61/61
• Manual on 4K full-screen, dark theme — verify the white right-edge line is gone during quick zoom-out (user-verified).