Buffer state_changed events across the sync window and preserve delivery order

[adborbas]

Changes

• Subscribe to state_changed before fetching the initial snapshot in both start() and resync(), buffering events that arrive during the fetch window and flushing them in arrival order once the snapshot lands. The flush runs on both the success and failure paths so no data is wiped and the buffer can't persist across a failed sync.
• Removed the per-event unstructured Task in both the state_changed subscription and the connection-transition delegate, handling each callback synchronously via MainActor.assumeIsolated. HAKit dispatches both callbacks on callbackQueue = .main, so this preserves HAKit's serial delivery order.
• Bounded bufferedEvents with a drop-oldest cap (maxBufferedEvents = 2000) plus a one-shot warning, so a stalled sync (live socket, unanswered getStates) can't grow the buffer without bound.
• Extracted HAConnectionManager.handleTransition(_:) from the delegate body.

Why

• Dropped events during the sync window: the snapshot was fully applied before the subscription was established, so any state_changed firing in that gap was never delivered and never reconciled — an entity could show a stale value (e.g. a light shown off after being turned on) until the next full resync. Subscribe-first buffering closes the gap.
• Reordering under load: wrapping each serially-delivered callback in its own unstructured Task discards HAKit's ordering guarantee. Back-to-back changes for one entity could apply out of order (persisting the older state), and connection flapping could compute the reconnect check against stale state and miss or spuriously fire onReconnect.

Notes

• Unverified against a live HA server (both findings are code-analysis-only and not reproducible in demo mode, which has no live event stream); verification is limited to unit-level buffering/ordering logic.
• Resync liveness tradeoff (intentional): during a resync (foreground / pull-to-refresh / reconnect), live updates are now held until the snapshot flushes rather than applied immediately. Nothing is lost and order is preserved on flush; this is the necessary cost of closing the reconnect gap and is documented in resync().
• Not included: an app-wide timeout on fetchSyncPayload for a hung sync — that changes sync-failure semantics broadly and is better scoped as its own task.
• Tests: HADataSyncBufferingTests (buffer/flush ordering, last-writer-wins, drop-oldest cap) and HAConnectionManagerTransitionTests (reconnect fires once, never spuriously). Full HemeraTests suite green (374 tests).