Phase 2b: log tailer, block history, stdlib WebSocket push

Adds real-time block detection via ckpool log tailing and a push
channel for the upcoming Svelte UI, all stdlib-only:

- logmon.Tailer follows ckpool.log with rotation/truncation survival
  (inode + size tracking) and parses "Solved and confirmed block N"
  into BlockEvent values.
- state.Aggregator grows a 256-entry block ring, an OnRefresh hook,
  and IngestBlockEvents which best-effort enriches events with the
  block hash via bitcoind getblockhash.
- httpapi.Hub implements RFC 6455 from scratch (SHA1 handshake,
  unmasked text frames out, masked frames in, ping keepalive,
  per-client write mutex, slow-client drop) so we don't pull in a
  ws dependency before we can go mod tidy.
- New routes: GET /api/blocks and GET /api/ws. Snapshot pushes fire
  on every poll tick and immediately on block-solve.

ZMQ hashblock subscription and SQLite persistence are deferred to
Phase 2b.5 once the s9pk packaging repo exists and we have a real
build environment for adding Go deps.

api/internal/state/blocks.go

@@ -0,0 +1,87 @@
+package state
+
+import (
+	"context"
+	"time"
+
+	"github.com/kamadopool/kamado-api/internal/logmon"
+)
+
+// BlockRecord is a found block, merged from a logmon event with bitcoind
+// data if available. Hash and Reward are populated best-effort via the
+// RPC lookup scheduled right after the log line is seen.
+type BlockRecord struct {
+	Height   int64     `json:"height"`
+	Hash     string    `json:"hash,omitempty"`
+	RewardBT float64   `json:"reward_btc,omitempty"`
+	FoundAt  time.Time `json:"found_at"`
+	Source   string    `json:"source"` // "logmon" for now; "zmq" later
+}
+
+// IngestBlockEvents reads block events from the tailer and appends them
+// to the snapshot's block history. Runs until ctx is cancelled.
+func (a *Aggregator) IngestBlockEvents(ctx context.Context, events <-chan logmon.BlockEvent) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case ev, ok := <-events:
+			if !ok {
+				return
+			}
+			rec := BlockRecord{
+				Height:  ev.Height,
+				FoundAt: ev.SeenAt,
+				Source:  "logmon",
+			}
+			// Best-effort enrich with hash via bitcoind.
+			if a.RPC != nil {
+				lookupCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+				if hash, err := a.RPC.GetBlockHash(lookupCtx, ev.Height); err == nil {
+					rec.Hash = hash
+				} else {
+					a.Log.Warn("bitcoind getblockhash failed", "height", ev.Height, "err", err)
+				}
+				cancel()
+			}
+			pushed := a.appendBlock(rec)
+			a.Log.Info("block recorded", "height", rec.Height, "hash", rec.Hash)
+			// Push immediately so WebSocket clients see the solve
+			// without waiting for the next poll tick.
+			if a.OnRefresh != nil {
+				a.OnRefresh(pushed)
+			}
+		}
+	}
+}
+
+// maxBlockHistory caps in-memory block history. Persistence comes in
+// Phase 2b.5 via SQLite; for now recent blocks survive only this
+// process's lifetime.
+const maxBlockHistory = 256
+
+// appendBlock records a new block and returns a copy of the current
+// snapshot with the updated history attached, suitable for an immediate
+// WebSocket broadcast.
+func (a *Aggregator) appendBlock(rec BlockRecord) Snapshot {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.blocks = append(a.blocks, rec)
+	if len(a.blocks) > maxBlockHistory {
+		a.blocks = a.blocks[len(a.blocks)-maxBlockHistory:]
+	}
+	snap := a.snap
+	snap.RecentBlocks = make([]BlockRecord, len(a.blocks))
+	copy(snap.RecentBlocks, a.blocks)
+	a.snap = snap
+	return snap
+}
+
+// Blocks returns a copy of the recent block history, newest last.
+func (a *Aggregator) Blocks() []BlockRecord {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	out := make([]BlockRecord, len(a.blocks))
+	copy(out, a.blocks)
+	return out
+}