fix(http): disable connection pooling to prevent stale connections in Lambda (#1094)

## Summary

Fixes a regression introduced in v93 where customers see a sharp
increase in "Max retries exceeded, returning request error" errors after
upgrading from v92.

- Disables HTTP connection pooling for the trace/stats flusher by
setting `pool_max_idle_per_host(0)`
- Prevents stale connections from being reused after Lambda
freeze/resume cycles

## Problem

PR #1018 introduced HTTP client caching for performance improvements.
However, the cached client maintains a connection pool that doesn't work
well with Lambda's freeze/resume execution model:

1. Lambda executes, HTTP client created with connection pool
2. Extension flushes traces, connections remain open in pool
3. Lambda **freezes** (paused between invocations - can be seconds to
minutes)
4. Lambda **resumes**, cached client reuses stale connections
5. TCP errors → "Max retries exceeded"

In v92, a new HTTP client was created per-flush, so there were never
stale connections to reuse.

## Solution

Disable connection pooling by setting `pool_max_idle_per_host(0)`. This
ensures each request gets a fresh connection, avoiding stale connection
issues while still benefiting from client caching (TLS session reuse,
configuration reuse, etc.).

This matches the pattern used in libdatadog's `new_client_periodic()`
which explicitly disables pooling with the comment:
> "This client does not keep connections because otherwise we would get
a pipe closed every second connection because of low keep alive in the
agent."


## Related

- Fixes [SVLS-8672](https://datadoghq.atlassian.net/browse/SVLS-8672)
- Fixes #1092
- Regression introduced in #1018

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: jordan gonzález <30836115+duncanista@users.noreply.github.com>

Author: 3 people

bottlecap/src/traces/http_client.rs

@@ -173,14 +173,25 @@ pub fn create_client(
         let proxy =
             hyper_http_proxy::Proxy::new(hyper_http_proxy::Intercept::Https, proxy.parse()?);
         let proxy_connector = hyper_http_proxy::ProxyConnector::from_proxy(connector, proxy)?;
-        let client = http_common::client_builder().build(proxy_connector);
+        // Disable connection pooling to avoid stale connections after Lambda freeze/resume.
+        // In Lambda, the execution environment can be frozen for seconds to minutes between
+        // invocations. Pooled connections become stale during this time, causing failures
+        // when reused. Setting pool_max_idle_per_host(0) ensures each request gets a fresh
+        // connection, matching the pattern used in libdatadog's new_client_periodic().
+        let client = http_common::client_builder()
+            .pool_max_idle_per_host(0)
+            .build(proxy_connector);
         debug!(
             "HTTP_CLIENT | Proxy connector created with proxy: {:?}",
             proxy_https
         );
         Ok(client)
     } else {
         let proxy_connector = hyper_http_proxy::ProxyConnector::new(connector)?;
-        Ok(http_common::client_builder().build(proxy_connector))
+        // Disable connection pooling to avoid stale connections after Lambda freeze/resume.
+        // See comment above for detailed explanation.
+        Ok(http_common::client_builder()
+            .pool_max_idle_per_host(0)
+            .build(proxy_connector))
     }
 }