host/engine: visible error/retry state for failed fetches + retry on network failure

Two engine fixes in web/orchestration.sx (rebuilt into the WASM bytecode) plus the
blog CSS that surfaces them.

1. Retry on NETWORK failure, not just HTTP errors. The fetch error/catch path (the
   real offline / DNS / connection-refused case) previously dispatched
   sx:requestError and stopped — only a non-ok HTTP response with an empty body
   ever reached handle-retry. So "no connection" never recovered. Now the catch
   path calls handle-retry too, so an sx-retry element actually self-heals when the
   connection returns (the cap bounds the backoff interval, not the attempt count —
   it retries forever).

2. Visible failure state. On any failed/aborted fetch the engine adds an `.sx-error`
   class to the element (cleared, with the retry backoff reset, on the next
   success). Without it a stuck retry loop is invisible — the picker just sits
   "Loading…". The blog shell ships CSS so the relate picker shows "Connection
   problem — retrying…" / "offline, retrying…" on .sx-error.

Platform-wide: any sx-get/sx-post element benefits, not just the picker.

Tests: relate-picker.spec.js gains a 6th case — abort relate-options, assert
.sx-error appears, un-abort, assert it clears and the picker repopulates (proving
the retry loop is live). 6/6 browser + 272/272 conformance. WASM web stack rebuilt
(orchestration.sxbc + the static hs-* copies refreshed by the same build).

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

web/orchestration.sx

@@ -223,6 +223,9 @@
                             el
                             "sx:responseError"
                             (dict "status" status "text" text))
+                          ;; visible failure state (CSS hooks .sx-error); cleared on
+                          ;; the next success in handle-fetch-success.
+                          (dom-add-class el "sx-error")
                           (if
                             (and text (> (len text) 0))
                             (handle-fetch-success
@@ -260,7 +263,14 @@
                             final-url
                             " — "
                             err))
-                        (dom-dispatch el "sx:requestError" (dict "error" err))))))))))))
+                        (dom-dispatch el "sx:requestError" (dict "error" err))
+                        ;; A network failure (offline, DNS, connection refused)
+                        ;; rejects the fetch — it never reaches the not-ok branch.
+                        ;; Mark the visible error state AND retry here too, so an
+                        ;; sx-retry element actually recovers when the connection
+                        ;; returns (previously only an empty HTTP error retried).
+                        (dom-add-class el "sx-error")
+                        (handle-retry el verb method final-url extraParams)))))))))))
     (define
       handle-fetch-success
       :effects (mutation io)
@@ -273,6 +283,10 @@
           (text :as string))
         (let
           ((resp-headers (process-response-headers get-header)))
+          ;; a successful response clears any visible error state + resets the
+          ;; retry backoff so the next failure starts fresh.
+          (dom-remove-class el "sx-error")
+          (dom-remove-attr el "data-sx-retry-ms")
           (dispatch-trigger-events el (get resp-headers "trigger"))
           (process-cache-directives el resp-headers text)
           (cond