Bound body read by per-request timeout (same class as Dart/Node fix)

reqwest's `Client::timeout` covers only the connect + initial-response
phase. The response body stream that backs `resp.text()` is not
covered — a slow or stalled body would otherwise hang the SDK call
indefinitely.

Same bug class as the Node SDK fix in ca0de42 and the Dart SDK fix
in 0e528c3. The Rust variant gets the same total-deadline treatment:
store the configured timeout on Transport and wrap `resp.text()` in
`tokio::time::timeout` so the body read is also bounded by it.

Verified locally: 25/25 unit + 2/2 doctests passing; clippy clean
under `-D warnings`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: pimfeltkamp

src/client.rs

@@ -176,6 +176,7 @@ impl ClientBuilder {
             base_url,
             user_agent,
             max_retries: self.max_retries.unwrap_or(DEFAULT_MAX_RETRIES),
+            timeout,
             http,
         });
 
@@ -211,6 +212,11 @@ pub(crate) struct Transport {
     base_url: String,
     user_agent: String,
     max_retries: u32,
+    // Per-request total deadline. reqwest's `Client::timeout` covers the
+    // connect + initial-response phase; the response body stream that
+    // backs `resp.text()` is *not* covered. We re-apply the same total
+    // timeout to the body read so a slow/stalled body can't hang the call.
+    timeout: Duration,
     http: reqwest::Client,
 }
 
@@ -301,10 +307,21 @@ impl Transport {
             .and_then(|v| v.to_str().ok())
             .and_then(parse_retry_after);
 
-        let text = resp
-            .text()
-            .await
-            .map_err(|e| Error::network(format!("failed to read body: {e}")))?;
+        // Bound the body read by the configured per-request timeout —
+        // reqwest's Client::timeout doesn't cover the body stream once
+        // .send() has resolved, so a slow body would otherwise hang.
+        let text = match tokio::time::timeout(self.timeout, resp.text()).await {
+            Ok(Ok(t)) => t,
+            Ok(Err(e)) => {
+                return Err(Error::network(format!("failed to read body: {e}")))
+            }
+            Err(_) => {
+                return Err(Error::timeout(format!(
+                    "response body read timed out after {}s",
+                    self.timeout.as_secs()
+                )))
+            }
+        };
         let parsed: Option<Value> = if text.is_empty() {
             None
         } else {