swarm UI: log an agent into claude from its card; the credentials go to bao and the agent picks them up

A new swarm service, `swarm-claude-login`, in its own container on the host
that sets `deploy.claude-login.enable` (defaulted on by `allSwarmServices`
where the host has the minter's store leaf, like the review classifier).

- swarm-ui: an agent card showing "login needed" gets a "log in" button.
  Its dialog starts the login, shows the URL claude printed, and takes the
  pasted code.
- swarm-controller: `POST/DELETE /api/agents/{name}/claude-login` and
  `POST /api/agents/{name}/claude-login/code`, behind the swarm UI's
  authelia-gated `/api/`, relay the steps to the minter as requests on
  `$SWARM.claude-login.request`.
- swarm-claude-login: runs `claude auth login` over piped stdio with HOME
  and CLAUDE_CONFIG_DIR in a per-login scratch dir, scrapes the first
  https URL, writes the code to stdin, and stores the `.credentials.json`
  at `swarm/agents/<agent>/claude-credentials` with a KV v2 write, a new
  version over any earlier one. The scratch dir goes on every exit path; a
  login waits 15 minutes for its code.
- hive-agent: while parked in `wait_for_login`, reads that leaf every 30 s
  under the agent's own cert and installs it only when its KV version is
  newer than the one recorded in `<harness>/claude-credentials-version`.
  An equal or older version is never put back, because claude rotates the
  refresh token and the stored copy is stale after the first refresh.
- swarm-secret-client: `claude_login` paths and `SecretStore::read_versioned`.
- Credentials: a `claude-login` store leaf minted by glue-bao-tls, a
  `swarm-claude-login` policy (create/update on
  `swarm/agents/+/claude-credentials`, read on its own queue client
  secret), an authelia machine client, and a `--claude-login-client`
  grant in the queue's auth-callout responder. The unit runs as a static
  system user.

The hive's own web-UI login is unchanged.

Refs #5268

swarm-secret-client/src/client.rs

@@ -218,6 +218,34 @@ impl SecretStore {
         }
     }
 
+    /// The newest version of the object at `path` and its KV v2 version
+    /// number, or `None` when nothing is stored there.
+    ///
+    /// One read, so the number is the one the value was stored as. Every
+    /// [`write`][Self::write] makes a larger one.
+    ///
+    /// # Errors
+    /// As [`read_optional`][Self::read_optional].
+    pub async fn read_versioned<T: DeserializeOwned>(
+        &self,
+        path: &str,
+    ) -> Result<Option<(T, u64)>, Error> {
+        let endpoint = vaultrs::api::kv2::requests::ReadSecretRequest::builder()
+            .mount(MOUNT)
+            .path(path)
+            .build()
+            .map_err(|e| Error::Settings(e.to_string()))?;
+        match vaultrs::api::exec_with_result(&self.inner, endpoint).await {
+            Ok(res) => {
+                let value = serde_json::from_value(res.data)
+                    .map_err(|source| vaultrs::error::ClientError::JsonParseError { source })?;
+                Ok(Some((value, res.metadata.version)))
+            }
+            Err(vaultrs::error::ClientError::APIError { code: 404, .. }) => Ok(None),
+            Err(e) => Err(e.into()),
+        }
+    }
+
     /// The keys stored directly under `path`, or none when nothing is.
     ///
     /// A key ending in `/` is a directory below `path` rather than an object;