Add foundation: middleware type, error types, and internal clock

Introduce the core building blocks for the httpx library:
- middleware.Middleware type and Chain() composer
- Error struct with sentinel errors (ErrRetryExhausted, ErrCircuitOpen, ErrNoHealthy)
- internal/clock package with Clock interface and MockClock for deterministic testing

internal/clock/clock.go

@@ -0,0 +1,150 @@
+package clock
+
+import (
+	"sync"
+	"time"
+)
+
+// Clock abstracts time operations for deterministic testing.
+type Clock interface {
+	Now() time.Time
+	Since(t time.Time) time.Duration
+	NewTimer(d time.Duration) Timer
+	After(d time.Duration) <-chan time.Time
+}
+
+// Timer abstracts time.Timer for testability.
+type Timer interface {
+	C() <-chan time.Time
+	Stop() bool
+	Reset(d time.Duration) bool
+}
+
+// System returns a Clock backed by the real system time.
+func System() Clock { return systemClock{} }
+
+type systemClock struct{}
+
+func (systemClock) Now() time.Time                         { return time.Now() }
+func (systemClock) Since(t time.Time) time.Duration        { return time.Since(t) }
+func (systemClock) NewTimer(d time.Duration) Timer         { return &systemTimer{t: time.NewTimer(d)} }
+func (systemClock) After(d time.Duration) <-chan time.Time { return time.After(d) }
+
+type systemTimer struct{ t *time.Timer }
+
+func (s *systemTimer) C() <-chan time.Time        { return s.t.C }
+func (s *systemTimer) Stop() bool                 { return s.t.Stop() }
+func (s *systemTimer) Reset(d time.Duration) bool { return s.t.Reset(d) }
+
+// Mock returns a manually-controlled Clock for tests.
+func Mock(now time.Time) *MockClock {
+	return &MockClock{now: now}
+}
+
+// MockClock is a deterministic clock for testing.
+type MockClock struct {
+	mu     sync.Mutex
+	now    time.Time
+	timers []*mockTimer
+}
+
+func (m *MockClock) Now() time.Time {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.now
+}
+
+func (m *MockClock) Since(t time.Time) time.Duration {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.now.Sub(t)
+}
+
+func (m *MockClock) NewTimer(d time.Duration) Timer {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	t := &mockTimer{
+		ch:       make(chan time.Time, 1),
+		deadline: m.now.Add(d),
+		active:   true,
+	}
+	m.timers = append(m.timers, t)
+	if d <= 0 {
+		t.fire(m.now)
+	}
+	return t
+}
+
+func (m *MockClock) After(d time.Duration) <-chan time.Time {
+	return m.NewTimer(d).C()
+}
+
+// Advance moves the clock forward by d and fires any expired timers.
+func (m *MockClock) Advance(d time.Duration) {
+	m.mu.Lock()
+	m.now = m.now.Add(d)
+	now := m.now
+	timers := m.timers
+	m.mu.Unlock()
+
+	for _, t := range timers {
+		t.mu.Lock()
+		if t.active && !now.Before(t.deadline) {
+			t.fire(now)
+		}
+		t.mu.Unlock()
+	}
+}
+
+// Set sets the clock to an absolute time and fires any expired timers.
+func (m *MockClock) Set(t time.Time) {
+	m.mu.Lock()
+	m.now = t
+	now := m.now
+	timers := m.timers
+	m.mu.Unlock()
+
+	for _, tmr := range timers {
+		tmr.mu.Lock()
+		if tmr.active && !now.Before(tmr.deadline) {
+			tmr.fire(now)
+		}
+		tmr.mu.Unlock()
+	}
+}
+
+type mockTimer struct {
+	mu       sync.Mutex
+	ch       chan time.Time
+	deadline time.Time
+	active   bool
+}
+
+func (t *mockTimer) C() <-chan time.Time { return t.ch }
+
+func (t *mockTimer) Stop() bool {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	was := t.active
+	t.active = false
+	return was
+}
+
+func (t *mockTimer) Reset(d time.Duration) bool {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	was := t.active
+	t.active = true
+	// Note: deadline will be recalculated on next Advance
+	t.deadline = time.Now().Add(d) // placeholder; mock users should use Advance
+	return was
+}
+
+// fire sends the time on the channel. Caller must hold t.mu.
+func (t *mockTimer) fire(now time.Time) {
+	t.active = false
+	select {
+	case t.ch <- now:
+	default:
+	}
+}