Add mock storage implementation for testing

[NP-compete]

Summary

The `storage.Store` interface exists but there's no mock implementation for testing.

Current State

```go
// internal/storage/interface.go
type Store interface {
Connect(ctx context.Context, cfg Config) error
Disconnect(ctx context.Context) error
IsHealthy(ctx context.Context) bool
// ... more methods
}
```

Implementations:

• `internal/storage/storage.go` - PostgreSQL
• `internal/storage/memory.go` - In-memory

No mock for testing.

Expected Outcome

Create `internal/storage/mock.go`:

```go
package storage

import (
"context"
"sync"
)

// MockStore is a mock implementation of Store for testing
type MockStore struct {
mu sync.RWMutex

// Storage
clients            map[string]*Client
authCodes          map[string]*AuthorizationCode
accessTokens       map[string]*AccessToken
refreshTokens      map[string]*RefreshToken

// Control behavior
ConnectError       error
GetClientError     error
StoreClientError   error
// ... more error controls

// Track calls
ConnectCalls       int
GetClientCalls     int
// ... more call tracking

}

func NewMockStore() *MockStore {
return &MockStore{
clients: make(map[string]*Client),
authCodes: make(map[string]*AuthorizationCode),
accessTokens: make(map[string]*AccessToken),
refreshTokens: make(map[string]*RefreshToken),
}
}

func (m *MockStore) Connect(ctx context.Context, cfg Config) error {
m.mu.Lock()
defer m.mu.Unlock()
m.ConnectCalls++
return m.ConnectError
}

// ... implement all interface methods
```

Usage in Tests

```go
func TestOAuthFlow(t *testing.T) {
store := storage.NewMockStore()
store.StoreClient(ctx, &storage.Client{ID: "test-client"})

service := oauth.NewService(store)
// ... test OAuth flow

}
```

Acceptance Criteria

• Mock implementation created
• All `Store` interface methods implemented
• Error injection capability
• Call tracking for assertions
• Thread-safe implementation
• Example tests using mock