Fix SSE streams stalling by using dedicated OTP actors

[dcrockwell]

Why

The existing sse_response function used chunked transfer encoding under the hood. Mist converted Stream(yielder) to Chunked(yielder), which meant the yielder iterated inside the mist handler process's mailbox. That mailbox also receives TCP messages (ACKs, window updates), so after 2–3 events the two would contend and the SSE stream would stall indefinitely.

This is the same class of problem Mist solved for WebSockets — long-lived connections need their own OTP actor with a dedicated mailbox.

What

New module: dream/servers/mist/sse

A complete SSE API that mirrors the WebSocket module's design:

• upgrade_to_sse — upgrades an HTTP request to an SSE connection backed by a dedicated OTP actor (uses the same stash-and-upgrade pattern as websocket.gleam)
• send_event — sends structured events to the client
• Event builders — event, event_name, event_id, event_retry for constructing SSE events with a pipeline syntax
• Action helpers — continue_connection, continue_connection_with_selector, stop_connection for controlling the actor lifecycle
• Opaque types (SSEConnection, Event, Action) that hide Mist internals from user code

Deprecation

response.sse_response is deprecated with a doc comment explaining the stalling bug and directing users to the new module. It is not removed — existing code continues to compile.

Testing

• Unit tests for event builders and action wrappers
• Tested documentation snippets (every code example from the docs compiles and runs)
• Full example app (examples/sse/) with Cucumber integration tests that verify events stream without stalling

Documentation

• New docs/guides/sse.md — comprehensive guide covering concepts, lifecycle, event builders, broadcasting, client-side EventSource, and testing
• Updated docs/reference/streaming-api.md with the new API reference
• Updated docs/guides/streaming.md to point to the new SSE guide

Version bump to 2.4.0 with CHANGELOG and release notes.

How

The new module follows the established stash-and-upgrade pattern from websocket.gleam:

1. Handler stashes the raw Mist request in the process dictionary before calling the controller
2. Controller calls upgrade_to_sse, which retrieves the stashed Mist request
3. upgrade_to_sse calls mist.server_sent_events with wrapped on_init and on_message callbacks
4. Mist spawns a dedicated OTP actor for the connection — SSE events and TCP messages no longer share a mailbox
5. The Mist response is stashed back, and the handler returns it to Mist instead of the dummy Dream response

User-facing callbacks (on_init, on_message) follow Dream's no-closures pattern — dependencies are passed explicitly rather than captured.

Test plan

• Unit tests pass (gleam test)
• Documentation snippets compile and run
• Example app builds successfully
• Integration tests (make test-integration in examples/sse/)
• Manual verification: connect with EventSource and confirm events stream continuously