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/ratelimit/factory.go

@@ -0,0 +1,56 @@
+//go:build !(js && wasm)
+
+package ratelimit
+
+import (
+	"time"
+
+	"github.com/dgraph-io/badger/v4"
+	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
+	"next.orly.dev/pkg/interfaces/loadmonitor"
+)
+
+// NewBadgerLimiter creates a rate limiter configured for a Badger database.
+// It automatically creates a BadgerMonitor for the provided database.
+func NewBadgerLimiter(config Config, db *badger.DB) *Limiter {
+	monitor := NewBadgerMonitor(db, 100*time.Millisecond)
+	return NewLimiter(config, monitor)
+}
+
+// NewNeo4jLimiter creates a rate limiter configured for a Neo4j database.
+// It automatically creates a Neo4jMonitor for the provided driver.
+// querySem should be the semaphore used to limit concurrent queries.
+// maxConcurrency is typically 10 (matching the semaphore size).
+func NewNeo4jLimiter(
+	config Config,
+	driver neo4j.DriverWithContext,
+	querySem chan struct{},
+	maxConcurrency int,
+) *Limiter {
+	monitor := NewNeo4jMonitor(driver, querySem, maxConcurrency, 100*time.Millisecond)
+	return NewLimiter(config, monitor)
+}
+
+// NewDisabledLimiter creates a rate limiter that is disabled.
+// This is useful when rate limiting is not configured.
+func NewDisabledLimiter() *Limiter {
+	config := DefaultConfig()
+	config.Enabled = false
+	return NewLimiter(config, nil)
+}
+
+// MonitorFromBadgerDB creates a BadgerMonitor from a Badger database.
+// Exported for use when you need to create the monitor separately.
+func MonitorFromBadgerDB(db *badger.DB) loadmonitor.Monitor {
+	return NewBadgerMonitor(db, 100*time.Millisecond)
+}
+
+// MonitorFromNeo4jDriver creates a Neo4jMonitor from a Neo4j driver.
+// Exported for use when you need to create the monitor separately.
+func MonitorFromNeo4jDriver(
+	driver neo4j.DriverWithContext,
+	querySem chan struct{},
+	maxConcurrency int,
+) loadmonitor.Monitor {
+	return NewNeo4jMonitor(driver, querySem, maxConcurrency, 100*time.Millisecond)
+}