Implement PID-controlled adaptive rate limiting for database operations

- Add LoadMonitor interface in pkg/interfaces/loadmonitor/ for database load metrics
- Implement PIDController with filtered derivative to suppress high-frequency noise
  - Proportional (P): immediate response to current error
  - Integral (I): eliminates steady-state offset with anti-windup clamping
  - Derivative (D): rate-of-change prediction with low-pass filtering
- Create BadgerLoadMonitor tracking L0 tables, compaction score, and cache hit ratio
- Create Neo4jLoadMonitor tracking query semaphore usage and latencies
- Add AdaptiveRateLimiter combining PID controllers for reads and writes
- Configure via environment variables:
  - ORLY_RATE_LIMIT_ENABLED: enable/disable rate limiting
  - ORLY_RATE_LIMIT_TARGET_MB: target memory limit (default 1500MB)
  - ORLY_RATE_LIMIT_*_K[PID]: PID gains for reads/writes
  - ORLY_RATE_LIMIT_MAX_*_MS: maximum delays
  - ORLY_RATE_LIMIT_*_TARGET: setpoints for reads/writes
- Integrate rate limiter into Server struct and lifecycle management
- Add comprehensive unit tests for PID controller behavior

Files modified:
- app/config/config.go: Add rate limiting configuration options
- app/main.go: Initialize and start/stop rate limiter
- app/server.go: Add rateLimiter field to Server struct
- main.go: Create rate limiter with appropriate monitor
- pkg/run/run.go: Pass disabled limiter for test instances
- pkg/interfaces/loadmonitor/: New LoadMonitor interface
- pkg/ratelimit/: New PID controller and limiter implementation

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

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

pkg/interfaces/loadmonitor/loadmonitor.go

@@ -0,0 +1,58 @@
+// Package loadmonitor defines the interface for database load monitoring.
+// This allows different database backends to provide their own load metrics
+// while the rate limiter remains database-agnostic.
+package loadmonitor
+
+import "time"
+
+// Metrics contains load metrics from a database backend.
+// All values are normalized to 0.0-1.0 where 0 means no load and 1 means at capacity.
+type Metrics struct {
+	// MemoryPressure indicates memory usage relative to a target limit (0.0-1.0+).
+	// Values above 1.0 indicate the target has been exceeded.
+	MemoryPressure float64
+
+	// WriteLoad indicates the write-side load level (0.0-1.0).
+	// For Badger: L0 tables and compaction score
+	// For Neo4j: active write transactions
+	WriteLoad float64
+
+	// ReadLoad indicates the read-side load level (0.0-1.0).
+	// For Badger: cache hit ratio (inverted)
+	// For Neo4j: active read transactions
+	ReadLoad float64
+
+	// QueryLatency is the recent average query latency.
+	QueryLatency time.Duration
+
+	// WriteLatency is the recent average write latency.
+	WriteLatency time.Duration
+
+	// Timestamp is when these metrics were collected.
+	Timestamp time.Time
+}
+
+// Monitor defines the interface for database load monitoring.
+// Implementations are database-specific (Badger, Neo4j, etc.).
+type Monitor interface {
+	// GetMetrics returns the current load metrics.
+	// This should be efficient as it may be called frequently.
+	GetMetrics() Metrics
+
+	// RecordQueryLatency records a query latency sample for averaging.
+	RecordQueryLatency(latency time.Duration)
+
+	// RecordWriteLatency records a write latency sample for averaging.
+	RecordWriteLatency(latency time.Duration)
+
+	// SetMemoryTarget sets the target memory limit in bytes.
+	// Memory pressure is calculated relative to this target.
+	SetMemoryTarget(bytes uint64)
+
+	// Start begins background metric collection.
+	// Returns a channel that will be closed when the monitor is stopped.
+	Start() <-chan struct{}
+
+	// Stop halts background metric collection.
+	Stop()
+}