feat(plan): add pluggable Storage interface (parity with todo toolset)

[Sayt-0]

Summary

Brings the plan builtin toolset to parity with todo: storage is now a
pluggable Storage interface with a default filesystem backend, an injection
seam, and per-instance construction instead of a process-wide-only singleton.

Acceptance criteria

#	Criterion	Status	Where
1	plan.Storage interface + default filesystem impl	yes	Storage interface; FilesystemStorage
2	plan.WithStorage(...) injects a custom backend	yes	WithStorage(Storage) Option, panics on nil (matches todo)
3	Per-instance constructor; default CreateToolSet() preserved	yes	New(opts ...Option); CreateToolSet() still returns the sync.OnceValue singleton
4	Revision bump owned by Storage.Upsert	yes	bump moved into FilesystemStorage.Upsert
5	Tests for filesystem and custom (in-memory) backend through the interface	yes	TestStorage_Conformance runs both backends over all four methods
6	No behavior change for standalone/CLI usage	yes	registry entry unchanged; filesystem default keeps atomic temp+rename, name validation, unreadable-file warnings, last-writer-wins bump

Interface

type Storage interface {
    Get(ctx context.Context, name string) (Plan, bool, error)
    Upsert(ctx context.Context, name, content, title, author string) (Plan, error)
    List(ctx context.Context) (plans []Summary, warnings []string, err error)
    Delete(ctx context.Context, name string) (deleted bool, err error)
}

Behavior preservation

• Handlers (write_plan / read_plan / list_plans / delete_plan) delegate to Storage rather than calling load/save directly.
• FilesystemStorage retains the original atomic write (temp file + rename), namePattern validation, missing-vs-corrupt distinction, corrupt-plan-still-deletable, filename-as-authoritative-key, and lazy directory creation on first write.
• The serialization mutex moves from ToolSet to FilesystemStorage; the shared singleton still routes every operation through one backend instance, so in-process collaboration is serialized exactly as before.
• Describe() reports the backend via fmt.Stringer, so the filesystem case still renders plan(dir=...).

Tests

Area	Coverage
Storage interface	TestStorage_Conformance over FilesystemStorage and an in-memory backend
Injection	custom-backend write/read/delete through WithStorage; WithStorage(nil) panics
Revision ownership	a non-bumping backend proves the handler adds no bump of its own
Output contract	nil List normalizes to "plans":[]; backend errors surface as IsError on every handler

All four handlers and Describe are at 100% statement coverage. Remaining uncovered lines in FilesystemStorage are OS-error paths (MkdirAll / ReadFile / Remove failures) that require fault injection and were uncovered before this change.

Design choices open to revision

These follow the issue text and the todo pattern, but can be changed if a different shape is preferred:

• New(dir string) becomes New(opts ...Option), a breaking signature change to an exported constructor (mirrors todo.New). If keeping New(dir string) is preferred, a separate constructor can be added instead.
• The in-memory backend lives in tests only; todo exports MemoryTodoStorage (its default). An exported plan.MemoryStorage can be added if embedders want an off-the-shelf ephemeral backend.
• Name validation lives in FilesystemStorage (the issue lists it under the filesystem implementation), so custom backends are free to define their own key rules. If validation should be guaranteed for all backends, it can move up into the handler.

Validation

• go build ./...: clean
• go test ./pkg/tools/builtin/plan/... ./pkg/teamloader/...: pass
• golangci-lint run ./pkg/tools/builtin/plan/...: clean

Closes #3237

[docker-agent]

Assessment: 🟢 APPROVE

The PR correctly refactors the plan toolset to match the todo pluggable-storage pattern. The drafter examined the diff for concurrency issues, nil-pointer risks, revision-bump ownership, interface conformance, and behavior regressions. The verifier confirmed all raised concerns are either pre-existing or non-regressions.

Areas checked:

• ✅ Mutex move from ToolSet → FilesystemStorage — all four methods (Get, Upsert, List, Delete) acquire s.mu correctly; no unguarded path introduced
• ✅ Singleton path (CreateToolSet / sync.OnceValue) — unchanged and still serializes all default-path agents
• ✅ Multi-instance serialization — independently-created New() instances were never cross-serialized in the old code either; behavior is unchanged
• ✅ Revision bump moved into FilesystemStorage.Upsert — no double-bump or missing bump
• ✅ WithStorage(nil) panic guard — consistent with todo pattern
• ✅ var _ Storage = (*FilesystemStorage)(nil) compile-time interface assertion present
• ✅ TestStorage_Conformance runs both FilesystemStorage and in-memory backend through all four methods
• ✅ Error propagation from Storage methods through all four handlers verified

No confirmed bugs introduced by this PR.