fix(ci): restore full CI green — test-matrix, clippy, rustfmt, and rustdoc gates

Root cause of the failing CI run was that examples/tests referencing
feature-gated items were auto-detected (no required-features), so
`--all-targets` compiled them under feature combinations where those
modules didn't exist. Fixes:

- mytheclipse Cargo.toml: declare the `high_level` example and
  `race_stress` integration test with required-features = ["full"];
  `cargo build --all-targets` now skips them when full is off. This
  clears the whole test-matrix (workspace default, all-features, and
  every single-feature config) which all failed on E0432/E0433.
- lib.rs: auto_metrics_service depends on service_builder, so regate it
  behind all(observability, resiliency) instead of observability alone
  (observability-only build compiled the module without resiliency).
- mytheclipse-tracing: gate `pub mod fmt` behind any
  tracing-subscriber-providing feature so --no-default-features compiles.
- mytheclipse-queue: gate `pub mod worker` behind in-memory (worker.rs
  requires tokio, only provided by in-memory).
- clippy -D warnings fixes: deprecated base64 0.22 free fns -> Engine
  (paseto), unused key field, needless mut (service_builder), unused
  import/dead var/missing is_empty (bg_join), dead is_expired (dlock),
  while-let-iterator->for (parallel_map), type_complexity (shutdown_guard),
  MutexGuard held across await (middleware, now clones Arc'd layers),
  if-let-Err->is_err (queue), unused CliBuilder fields now wired into clap.
- rustdoc -D warnings: resolve retry/MetricsBridge/CircuitBreaker/KeyRing
  intra-doc links and fix the unparseable lifecycle.rs code fence.
- cargo fmt --all to satisfy the Rustfmt gate.

crates/mytheclipse-http/src/resilient_client.rs

@@ -77,25 +77,22 @@ impl ResilientHttpClient {
 
     /// Sends a pre-built `RequestBuilder` through the resiliency pipeline.
     /// Returns the response bytes on success.
-    pub async fn send(
-        &self,
-        req: RequestBuilder,
-    ) -> Result<Vec<u8>, RunError<HttpError>> {
+    pub async fn send(&self, req: RequestBuilder) -> Result<Vec<u8>, RunError<HttpError>> {
         let span = tracing::info_span!("resilient_http_send");
         let op = move || {
             let req = req.try_clone().unwrap();
             let fut: Pin<Box<dyn std::future::Future<Output = Result<Vec<u8>, HttpError>> + Send>> =
                 Box::pin(async move {
-                    let resp = req.send().instrument(tracing::trace_span!("http_send")).await?;
+                    let resp = req
+                        .send()
+                        .instrument(tracing::trace_span!("http_send"))
+                        .await?;
                     let bytes = resp.bytes().await?;
                     Ok::<Vec<u8>, HttpError>(bytes.to_vec())
                 });
             fut
         };
-        self.builder
-            .run(op)
-            .instrument(span)
-            .await
+        self.builder.run(op).instrument(span).await
     }
 
     /// Convenience: GET `url`, returning response bytes.