add streaming examples and module documentation

Cargo.lock

···
  "cid",
  "ed25519-dalek",
  "futures",
+ "futures-lite",
  "getrandom 0.3.4",
  "http",
  "ipld-core",

crates/jacquard-common/Cargo.toml

···
 features = ["arithmetic"]
 
 [dev-dependencies]
-tokio = { version = "1", features = ["macros", "rt"] }
+tokio = { version = "1", features = ["macros", "rt", "rt-multi-thread"] }
+futures-lite = "2.6"
 
 [package.metadata.docs.rs]
 features = [ "crypto-k256", "crypto-k256", "crypto-p256"]

crates/jacquard-common/examples/streaming_download.rs

···
+//! Example: Download large file using streaming
+#![cfg(all(feature = "streaming", feature = "reqwest-client"))]
+
+use jacquard_common::http_client::HttpClientExt;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = reqwest::Client::new();
+
+    let request = http::Request::builder()
+        .uri("https://httpbin.org/bytes/1024")
+        .body(vec![])
+        .unwrap();
+
+    let response = client.send_http_streaming(request).await?;
+    println!("Status: {}", response.status());
+    println!("Headers: {:?}", response.headers());
+
+    let (_parts, _body) = response.into_parts();
+    println!("Received streaming response body (ByteStream)");
+
+    // Note: To iterate over chunks, use futures_lite::StreamExt on the pinned inner stream:
+    // let mut stream = Box::pin(body.into_inner());
+    // while let Some(chunk) = stream.as_mut().try_next().await? { ... }
+
+    Ok(())
+}

crates/jacquard-common/examples/streaming_upload.rs

···
+//! Example: Upload data using streaming request body
+#![cfg(all(feature = "streaming", feature = "reqwest-client"))]
+
+use jacquard_common::http_client::HttpClientExt;
+use futures::stream;
+use bytes::Bytes;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = reqwest::Client::new();
+
+    // Create a stream of data chunks
+    let chunks = vec![
+        Bytes::from("Hello, "),
+        Bytes::from("streaming "),
+        Bytes::from("world!"),
+    ];
+    let body_stream = stream::iter(chunks);
+
+    // Build request and split into parts
+    let request = http::Request::builder()
+        .method(http::Method::POST)
+        .uri("https://httpbin.org/post")
+        .body(())
+        .unwrap();
+
+    let (parts, _) = request.into_parts();
+
+    let response = client.send_http_bidirectional(parts, body_stream).await?;
+    println!("Status: {}", response.status());
+
+    Ok(())
+}

crates/jacquard-common/src/stream.rs

···
 //! Stream abstractions for HTTP request/response bodies
+//!
+//! This module provides platform-agnostic streaming types for handling large
+//! payloads efficiently without loading everything into memory.
+//!
+//! # Features
+//!
+//! - [`ByteStream`]: Streaming response bodies
+//! - [`ByteSink`]: Streaming request bodies
+//! - [`StreamError`]: Concrete error type for streaming operations
+//!
+//! # Platform Support
+//!
+//! Uses `n0-future` for platform-agnostic async streams that work on both
+//! native and WASM targets without requiring `Send` bounds on WASM.
+//!
+//! # Examples
+//!
+//! ## Streaming Download
+//!
+//! ```no_run
+//! # #[cfg(all(feature = "streaming", feature = "reqwest-client"))]
+//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+//! use jacquard_common::http_client::{HttpClient, HttpClientExt};
+//! use futures_lite::StreamExt;
+//!
+//! let client = reqwest::Client::new();
+//! let request = http::Request::builder()
+//!     .uri("https://example.com/large-file")
+//!     .body(vec![])
+//!     .unwrap();
+//!
+//! let response = client.send_http_streaming(request).await?;
+//! let (_parts, body) = response.into_parts();
+//! let mut stream = Box::pin(body.into_inner());
+//!
+//! // Use futures_lite::StreamExt for iteration
+//! while let Some(chunk) = stream.as_mut().try_next().await? {
+//!     // Process chunk without loading entire file into memory
+//! }
+//! # Ok(())
+//! # }
+//! ```
 
 use std::error::Error;
 use std::fmt;