feat: create v2-prep branch with comprehensive planning

Restructured project for V2 refactor:

**Structure Changes:**
- Moved all V1 code to orig/ folder (preserved with git mv)
- Created docs/planning/ directory
- Added orig/README_V1.md explaining V1 preservation

**Planning Documents:**
- 00_V2_MASTER_PLAN.md: Complete architecture overview
  - Executive summary of critical V1 issues
  - High-level component architecture diagrams
  - 5-phase implementation roadmap
  - Success metrics and risk mitigation

- 07_TASK_BREAKDOWN.md: Atomic task breakdown
  - 99+ hours of detailed tasks
  - Every task < 2 hours (atomic)
  - Clear dependencies and success criteria
  - Organized by implementation phase

**V2 Key Improvements:**
- Per-exchange parsers (factory pattern)
- Multi-layer strict validation
- Multi-index pool cache
- Background validation pipeline
- Comprehensive observability

**Critical Issues Addressed:**
- Zero address tokens (strict validation + cache enrichment)
- Parsing accuracy (protocol-specific parsers)
- No audit trail (background validation channel)
- Inefficient lookups (multi-index cache)
- Stats disconnection (event-driven metrics)

Next Steps:
1. Review planning documents
2. Begin Phase 1: Foundation (P1-001 through P1-010)
3. Implement parsers in Phase 2
4. Build cache system in Phase 3
5. Add validation pipeline in Phase 4
6. Migrate and test in Phase 5

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

orig/pkg/lifecycle/shutdown_manager_test.go

@@ -0,0 +1,111 @@
+package lifecycle
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type testShutdownHook struct {
+	errs        map[string]error
+	lastFailure error
+}
+
+func (h *testShutdownHook) OnShutdownStarted(ctx context.Context) error {
+	return h.errs["OnShutdownStarted"]
+}
+
+func (h *testShutdownHook) OnModulesStopped(ctx context.Context) error {
+	return h.errs["OnModulesStopped"]
+}
+
+func (h *testShutdownHook) OnCleanupStarted(ctx context.Context) error {
+	return h.errs["OnCleanupStarted"]
+}
+
+func (h *testShutdownHook) OnShutdownCompleted(ctx context.Context) error {
+	return h.errs["OnShutdownCompleted"]
+}
+
+func (h *testShutdownHook) OnShutdownFailed(ctx context.Context, err error) error {
+	h.lastFailure = err
+	return h.errs["OnShutdownFailed"]
+}
+
+func TestShutdownManagerErrorAggregation(t *testing.T) {
+	sm := NewShutdownManager(nil, ShutdownConfig{})
+	sm.logger = nil
+
+	txHash := "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	firstErr := fmt.Errorf("first failure on %s", txHash)
+	secondErr := errors.New("second")
+
+	sm.recordShutdownError("first error", firstErr)
+	sm.recordShutdownError("second error", secondErr)
+
+	if got := len(sm.shutdownErrors); got != 2 {
+		t.Fatalf("expected 2 recorded errors, got %d", got)
+	}
+
+	combined := sm.combinedShutdownError()
+	if combined == nil {
+		t.Fatal("expected combined shutdown error, got nil")
+	}
+	if !errors.Is(combined, firstErr) || !errors.Is(combined, secondErr) {
+		t.Fatalf("combined error does not contain original errors: %v", combined)
+	}
+
+	exportedErrors := sm.ShutdownErrors()
+	if len(exportedErrors) != 2 {
+		t.Fatalf("expected exported error slice of length 2, got %d", len(exportedErrors))
+	}
+
+	details := sm.ShutdownErrorDetails()
+	if len(details) != 2 {
+		t.Fatalf("expected error detail slice of length 2, got %d", len(details))
+	}
+	if details[0].TxHash != txHash {
+		t.Fatalf("expected recorded error to track tx hash %s, got %s", txHash, details[0].TxHash)
+	}
+	if details[0].Err == nil || !strings.Contains(details[0].Err.Error(), "tx_hash="+txHash) {
+		t.Fatalf("expected recorded error message to include tx hash, got %v", details[0].Err)
+	}
+}
+
+func TestShutdownManagerCallHooksAggregatesErrors(t *testing.T) {
+	sm := NewShutdownManager(nil, ShutdownConfig{})
+	sm.logger = nil
+	sm.shutdownErrors = nil
+
+	hookErrA := errors.New("hookA failure")
+	hookErrB := errors.New("hookB failure")
+	hookA := &testShutdownHook{
+		errs: map[string]error{
+			"OnShutdownFailed": hookErrA,
+		},
+	}
+	hookB := &testShutdownHook{
+		errs: map[string]error{
+			"OnShutdownFailed": hookErrB,
+		},
+	}
+
+	sm.shutdownHooks = []ShutdownHook{hookA, hookB}
+
+	cause := errors.New("original failure")
+	err := sm.callHooks(context.Background(), "OnShutdownFailed", cause)
+	if err == nil {
+		t.Fatal("expected aggregated error from hooks, got nil")
+	}
+	if !errors.Is(err, hookErrA) || !errors.Is(err, hookErrB) {
+		t.Fatalf("expected aggregated error to contain hook failures, got %v", err)
+	}
+	if hookA.lastFailure != cause || hookB.lastFailure != cause {
+		t.Fatal("expected hook to receive original failure cause")
+	}
+	if len(sm.ShutdownErrors()) != 2 {
+		t.Fatalf("expected shutdown errors to be recorded for each hook failure, got %d", len(sm.ShutdownErrors()))
+	}
+}