[P2] Add streaming text to the Learn feature

[AndresL230]

Problem

The tutor chat is request/response, not streamed. POST /api/learn/chat (backend/routes/learn.py:552) runs the model to completion and returns a single JSON dict, so the user watches a spinner for the whole multi-second generation instead of seeing tokens as they arrive.

• Agent path — _chat_via_agent (learn.py:443) calls await agent.run(user_message, ...) (:499) and returns {reply, graph_update: {}, mastery_changes: []} (graph changes are persisted in-band by apply_graph_update_tool during the run).
• Legacy path — _legacy_chat (learn.py:509) calls the blocking call_gemini_multiturn and returns {reply, graph_update, mastery_changes}.
• Frontend — sendChat (frontend/src/lib/api.ts:105) is a plain fetchJSON that awaits the full reply; ChatPanel.tsx only renders the assistant bubble once it resolves.

SSE plumbing already exists and is proven on the document-upload path (api.ts:426-448 consuming streamSSE from lib/sse.ts). This issue wires the same mechanism into chat.

Proposal

Add a streaming chat turn over SSE — reuse streamSSE on the client and Pydantic AI's agent.run_stream() on the server. Stream assistant text token-by-token, then emit a terminal event carrying the post-run graph_update/mastery_changes. Keep the existing non-streaming endpoint as a fallback.

Scope

Backend — backend/routes/learn.py, backend/agents/chat_tutor.py

• Add a streaming entrypoint — either POST /api/learn/chat/stream or content-negotiated on /chat — returning StreamingResponse(media_type="text/event-stream").
• Replace await agent.run(...) with async with agent.run_stream(...) as result: and iterate result.stream_text(delta=True), emitting one SSE token event per delta. Reuse the existing run_kwargs (deps, message_history, model override, _build_pro_model_settings()) and the use_shared_context constraint injection from _chat_via_agent.
• Preserve message-persistence ordering. Today the agent path persists messages out-of-band in chat() (_load_message_history loads prior turns BEFORE the new turn; the assistant row is written after). The stream must save the assistant message once, after the stream completes — and must NOT persist a partial reply on client disconnect/abort.
• Tool-call nuance. chat_tutor registers apply_graph_update_tool, which runs and persists graph changes mid-run. Stream text only for the final model output; after run_stream finishes, emit a terminal done event with {graph_update, mastery_changes}. This is the natural seam to also emit [P2] Live-update Learn progress card via SSE graph deltas #74's graph_update deltas — do them together.
• Errors + tracing. On model/tool failure mid-stream, emit a terminal error event (mirror the upload stream); keep _legacy_chat reachable for non-streaming clients. Stamp request_id / X-Request-ID on the stream for trace correlation, matching chat() (:557-563).

Frontend — frontend/src/lib/api.ts, components/ChatPanel.tsx, screens/Learn.tsx

• Add a streaming sendChatStream(..., { onToken, signal }) that consumes streamSSE<ChatEvent> exactly like the upload path (api.ts:426-448): append each token delta to the in-progress assistant bubble; on done, reconcile {graph_update, mastery_changes} into Learn state.
• ChatPanel.tsx: render a live streaming assistant bubble with a typing indicator, finalized on done; disable the composer while streaming; support stop/abort via the AbortController signal.
• Clean up the SSE reader on unmount / session switch (avoid the leaked-stream class of bug seen in [P1] Social realtime correctness: duplicate bubbles, unscoped reaction reloads, has_more off-by-one #131 / [P2] Notetaker data loss: dropped debounced autosave + lost course context on send-to-tutor #133).
• Keep the non-streaming sendChat for IS_LOCAL_MODE and as a fallback.

Non-goals

• Reworking mastery computation or the agent tool surface.
• Streaming tool-call progress to the UI (only the final assistant text streams).
• Changing /action or /mode-switch (separate follow-ups if wanted).

Dependencies / coordination

• [P2] Live-update Learn progress card via SSE graph deltas #74 (live progress card via SSE graph deltas) should ride the same stream — implement together; the done / graph_update event is shared.
• [P1] Agent-migration regressions: mastery-via-chat gone, empty concepts_covered, no usage limits #127 (agent no longer emits mastery deltas) gates the graph-delta half being meaningful.

Acceptance

• Sending a tutor message renders assistant text incrementally (token-by-token), with no full-response spinner.
• The final bubble matches the non-streamed reply; graph_update / mastery_changes are applied exactly once on done.
• Aborting / navigating mid-stream cancels cleanly: no partial assistant row persisted, no console errors, no leaked reader.
• Non-streaming fallback still works (local mode + clients that don't request the stream).

[AndresL230]

Implemented by PR #349 (merged as aa2a31c): tutor replies now stream over SSE via POST /api/learn/chat/stream and /start-session/stream, with live token rendering and a Stop control in the Learn UI. Verified by the full local e2e lane (11/11 journeys + oracles) and the streamed function-mode seam tests.