fix(http): fail fast when no HTTP client is available (PAL code-review)

A 3-model PAL review of the 0.8.2 changes flagged that the Phase 5
NetworkError("No HTTP client available") raise (added when a get/get_sync
has neither an adafruit session nor urllib) was raised INSIDE the retry
loop, so the broad `except Exception` caught it and retried 3× with
backoff — burning up to ~6s of real time.sleep on the sync path for a
permanent, un-retryable configuration state. post()'s no-client path
also fell through to `self.urllib.Request(...)` with urllib=None, whose
AttributeError got wrapped into a confusing NetworkError message.

Add a fail-fast preflight (no adafruit session AND no urllib -> raise
NetworkError immediately) before the retry loop in get()/get_sync() and
before the try in post(). Desktop always has urllib, so this path only
triggers on a genuinely clientless CircuitPython config; existing tests
are unaffected (verified: 698 lib + 95 app green). Adds
TestNoHttpClientFailsFast covering all three entry points (asserts no
retry sleep, and post() raises a clean "No HTTP client available").

Also fixes a stale post() docstring that still referenced the removed
`.error` response attribute.

The review confirmed the load-bearing invariants held: EBUSY socket
detach/close preserved, OTA (ok, reason) tuple contract intact, the
web-settings flag handoff sound, and the shared sim-backend wiring order
correct.

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

Author: czei

src/scrollkit/network/http_client.py

@@ -207,6 +207,12 @@ async def get(self, url, headers=None, max_retries=3):
             if mock_resp is not None:
                 return mock_resp
 
+        # No HTTP client at all (no adafruit session, no urllib) is a permanent
+        # configuration state, not a transient blip — fail fast instead of
+        # burning the retry loop's backoff on it.
+        if not (self.using_adafruit and self.session) and not self.urllib:
+            raise NetworkError("No HTTP client available")
+
         while retry_count < max_retries:
             try:
                 if self.using_adafruit and self.session:
@@ -383,7 +389,8 @@ async def post(self, url, data, headers=None):
         block the synchronous asyncio loop and trip the watchdog. POST is
         single-shot (no retry loop), but a failure is recorded via
         ``_note_failure`` so a wedged session still gets rebuilt on the next
-        request, and the cause is surfaced on ``.error`` / ``last_error``.
+        request, raises ``NetworkError``, and the cause is retained on
+        ``last_error``.
         """
         if headers is None:
             headers = {
@@ -392,6 +399,11 @@ async def post(self, url, data, headers=None):
             }
         if isinstance(data, dict):
             data = json.dumps(data)
+        # Raise cleanly BEFORE the try so the "no client" NetworkError isn't
+        # re-wrapped by the except below (and so the urllib branch never calls
+        # None.Request(...) -> AttributeError when urllib is absent on device).
+        if not (self.using_adafruit and self.session) and not self.urllib:
+            raise NetworkError("No HTTP client available")
         try:
             if self.using_adafruit and self.session:
                 resp = None
@@ -438,6 +450,11 @@ def get_sync(self, url, headers=None, max_retries=3):
         retry_count = 0
         last_error = None
 
+        # Fail fast on a permanent no-client state instead of sleeping through
+        # the retry backoff (blocking real time.sleep on the sync path).
+        if not (self.using_adafruit and self.session) and not self.urllib:
+            raise NetworkError("No HTTP client available")
+
         while retry_count < max_retries:
             try:
                 if self.using_adafruit and self.session:

test/unit/network/test_http_client_errors.py

@@ -108,4 +108,42 @@ async def test_post_request_error(self):
             assert mock_logger.return_value.error.called
             # The cause is carried in the NetworkError message and on last_error.
             assert "Connection error" in str(exc.value)
-            assert str(client.last_error) == "Connection error"
+            assert str(client.last_error) == "Connection error"
+
+
+class TestNoHttpClientFailsFast:
+    """A permanent 'no HTTP client' state (no adafruit session AND no urllib)
+    must raise NetworkError immediately, not burn the retry backoff on a
+    condition no retry can fix (the sync path's time.sleep is real blocking)."""
+
+    def _no_client(self):
+        client = HttpClient(session=None)
+        client.using_adafruit = False
+        client.session = None
+        client.urllib = None
+        return client
+
+    @pytest.mark.asyncio
+    async def test_get_raises_immediately_without_retry(self):
+        client = self._no_client()
+        with patch('asyncio.sleep', new=AsyncMock()) as slept:
+            with patch('scrollkit.network.http_client._logger'):
+                with pytest.raises(NetworkError):
+                    await client.get("https://example.com/api", max_retries=3)
+        slept.assert_not_called()
+
+    def test_get_sync_raises_immediately_without_retry(self):
+        client = self._no_client()
+        with patch('time.sleep') as slept:
+            with patch('scrollkit.network.http_client._logger'):
+                with pytest.raises(NetworkError):
+                    client.get_sync("https://example.com/api", max_retries=3)
+        slept.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_post_raises_clean_network_error_not_attributeerror(self):
+        client = self._no_client()
+        with patch('scrollkit.network.http_client._logger'):
+            with pytest.raises(NetworkError) as exc:
+                await client.post("https://example.com/api", data={"a": 1})
+        assert "No HTTP client available" in str(exc.value)