Flatten repo structure: move crawler/ to root, remove vqa/ and immoweb/

The crawler subdirectory was the only active project. Moving it to the
repo root simplifies paths and removes the unnecessary nesting. The
vqa/ and immoweb/ directories were legacy/unused and have been removed.

Updated .drone.yml, .gitignore, .claude/ docs, and skills to reflect
the new flat structure.

rec/circuit_breaker.py

@@ -0,0 +1,137 @@
+"""Circuit breaker pattern for protecting against cascading failures."""
+from __future__ import annotations
+
+import enum
+import logging
+import time
+from dataclasses import dataclass
+
+from rec.exceptions import CircuitBreakerOpenError
+
+logger = logging.getLogger("uvicorn.error")
+
+
+class CircuitState(enum.Enum):
+    """Circuit breaker states."""
+
+    CLOSED = "closed"  # Normal operation
+    OPEN = "open"  # Too many failures, blocking requests
+    HALF_OPEN = "half_open"  # Testing if service recovered
+
+
+@dataclass
+class CircuitBreaker:
+    """Circuit breaker for protecting against cascading failures.
+
+    Implements the circuit breaker pattern:
+    - CLOSED: Requests pass through normally, failures are counted
+    - OPEN: After N consecutive failures, circuit opens and blocks all requests
+    - HALF_OPEN: After recovery timeout, allow one request to test if service recovered
+
+    Attributes:
+        failure_threshold: Number of consecutive failures before opening.
+        recovery_timeout: Seconds to wait before attempting half-open state.
+        state: Current circuit state.
+        failure_count: Count of consecutive failures.
+        last_failure_time: Timestamp of last failure.
+        last_state_change: Timestamp of last state change.
+    """
+
+    failure_threshold: int
+    recovery_timeout: float
+    state: CircuitState = CircuitState.CLOSED
+    failure_count: int = 0
+    last_failure_time: float = 0.0
+    last_state_change: float = 0.0
+
+    def __post_init__(self) -> None:
+        """Initialize state change timestamp."""
+        self.last_state_change = time.time()
+
+    def call(self) -> None:
+        """Check if a request should be allowed.
+
+        Raises:
+            CircuitBreakerOpenError: If circuit is open and blocking requests.
+        """
+        current_time = time.time()
+
+        if self.state == CircuitState.OPEN:
+            # Check if we should transition to half-open
+            if current_time - self.last_failure_time >= self.recovery_timeout:
+                self._transition_to_half_open()
+            else:
+                raise CircuitBreakerOpenError(
+                    f"Circuit breaker is open. "
+                    f"Waiting {self.recovery_timeout - (current_time - self.last_failure_time):.1f}s "
+                    f"before retry."
+                )
+
+        # Allow request to proceed (CLOSED or HALF_OPEN)
+
+    def record_success(self) -> None:
+        """Record a successful request."""
+        if self.state == CircuitState.HALF_OPEN:
+            # Service has recovered, close the circuit
+            self._transition_to_closed()
+
+        # Reset failure count on success
+        self.failure_count = 0
+
+    def record_failure(self) -> None:
+        """Record a failed request."""
+        self.failure_count += 1
+        self.last_failure_time = time.time()
+
+        if self.state == CircuitState.HALF_OPEN:
+            # Test request failed, reopen circuit
+            self._transition_to_open()
+        elif self.state == CircuitState.CLOSED:
+            # Check if we should open the circuit
+            if self.failure_count >= self.failure_threshold:
+                self._transition_to_open()
+
+    def _transition_to_open(self) -> None:
+        """Transition to OPEN state."""
+        self.state = CircuitState.OPEN
+        self.last_state_change = time.time()
+        logger.warning(
+            f"Circuit breaker OPENED after {self.failure_count} consecutive failures. "
+            f"Will retry in {self.recovery_timeout}s"
+        )
+
+    def _transition_to_half_open(self) -> None:
+        """Transition to HALF_OPEN state."""
+        self.state = CircuitState.HALF_OPEN
+        self.last_state_change = time.time()
+        logger.info("Circuit breaker entering HALF_OPEN state, testing service recovery")
+
+    def _transition_to_closed(self) -> None:
+        """Transition to CLOSED state."""
+        self.state = CircuitState.CLOSED
+        self.last_state_change = time.time()
+        self.failure_count = 0
+        logger.info("Circuit breaker CLOSED, service recovered")
+
+    def reset(self) -> None:
+        """Manually reset the circuit breaker to CLOSED state."""
+        self.state = CircuitState.CLOSED
+        self.failure_count = 0
+        self.last_failure_time = 0.0
+        self.last_state_change = time.time()
+        logger.info("Circuit breaker manually reset to CLOSED state")
+
+    @property
+    def is_open(self) -> bool:
+        """Check if circuit is currently open."""
+        return self.state == CircuitState.OPEN
+
+    @property
+    def is_closed(self) -> bool:
+        """Check if circuit is currently closed."""
+        return self.state == CircuitState.CLOSED
+
+    @property
+    def is_half_open(self) -> bool:
+        """Check if circuit is currently half-open."""
+        return self.state == CircuitState.HALF_OPEN