feat: stream HTTP responses (SSE/chunked) and generalise scheduled push to core

[outofcoffee]

Summary

Adds incremental HTTP streaming to the rest and openapi plugins via stream: true, and generalises the websocket plugin's multiple-response and scheduled-frame machinery into a protocol-agnostic core (internal/emit) that HTTP and websocket now share.

Two capabilities on a streamed resource:

• Fixed sequence — a responses list is written and flushed one chunk at a time, paced by each block's delay. Ideal for an OpenAI-style token stream ending in [DONE].
• Open-ended push — a schedule on a streamed resource pushes further responses over the open connection until its limit is reached or the client disconnects (SSE keepalive, progress, live data).

plugin: rest
resources:
  - path: /v1/chat/completions
    method: POST
    stream: true
    responses:
      - content: "data: {...}\n\n"
        headers: { Content-Type: text/event-stream }
        delay: { exact: 50 }
      - content: "data: [DONE]\n\n"

The generalisation (DRY)

New core package internal/emit:

• Sink — abstracts "send one processed response body" (a websocket text frame, or an HTTP flushed chunk).
• EmitResponses — the shared process-then-emit loop (per-block delay/file/content/template).
• ScheduleHost — runs connection- or request-scoped schedules through the existing internal/scheduler, emitting via a Sink.

The websocket plugin is refactored onto these (a frameSink + ScheduleHost), deleting its bespoke send/schedule code. OpenAPI inherits streaming for free because it already serves responses through the REST pipeline. The top-level engine-lifetime scheduler is unchanged (no client sink; avoids an import cycle).

Behaviour & safety

• Chunked (Transfer-Encoding: chunked); status/headers taken from the first chunk. SSE framing is authored in the content, so the same mechanism serves NDJSON or any chunked format.
• Client disconnect stops request-scoped schedules promptly (via r.Context()).
• Non-flushable connections (AWS Lambda adapter): chunks are concatenated into one buffered response and schedules are skipped with a warning.
• Validation: multiple responses or a schedule on an HTTP resource require stream: true; stream: true with nothing to stream is rejected; schedule-entry checks are shared between websocket and HTTP.

Tests & docs

• Unit tests for internal/emit (emit loop, buffered fallback, schedule limit + context-cancel), streaming validation tests. Full suite: 30 packages pass; go test -race clean on the concurrency-sensitive packages.
• New examples/rest/sse-streaming example and docs/streaming.md.

Verified end-to-end on the native engine: 50 ms SSE pacing to [DONE]; scheduled push honouring limit and stopping on client disconnect; and OpenAPI streaming through the shared pipeline.