net.http: stream response callbacks and stop limits over HTTP/2

[quaesitor-scientiam]

What

Adds real streaming-response support to the HTTP/2 fetch path. Previously, the
HTTP/2 shim (#27362) buffered the entire response body, so requests using
`on_progress` / `on_progress_body` / `stop_copying_limit` /
`stop_receiving_limit` were forced onto HTTP/1.1 to preserve their semantics.
This PR makes them work over HTTP/2 too.

Closes #27368.

fn on_body(r &http.Request, chunk []u8, body_so_far u64, body_expected u64, status int) ! {
    eprintln('chunk ${chunk.len} bytes, total ${body_so_far}')
}

resp := http.fetch(
    url: 'https://example.com/large'
    enable_http2: true
    on_progress_body: on_body  // now fires per DATA frame on h2
)!

Changes

File	Change
h2_conn.v	new H2DataFn type; H2ClientRequest gains on_data, stop_copying_limit, stop_receiving_limit; read_response honors them while reading DATA frames
backend.c.v	h2_do adapts the request's on_progress / on_progress_body into a single H2DataFn closure and threads the stop limits through; removes the streaming gate so enable_http2 is no longer overridden
h2_client.v	drops the now-unused uses_response_streaming helper
request.v, http.v	updated enable_http2 doc — streaming callbacks now work on h2; on_progress fires per DATA payload (rather than per raw network read)
h2_conn_test.v	new streaming tests over the in-memory transport
h2_client_test.v	removes the obsolete test_uses_response_streaming

Design

• H2ClientRequest carries the streaming options so H2Conn stays
  decoupled from net.http.Request. The shim layer adapts Request's callbacks
  onto them.
• on_data fires per DATA frame, with (chunk, body_so_far, body_expected, status). body_so_far is cumulative (including this chunk), body_expected
  is Content-Length if present (else 0), and status is the response status
  (known since headers arrive before DATA).
• stop_copying_limit: caps the cumulative body bytes copied into
  resp.body; further chunks are dropped from the body but the callback still
  fires, matching the HTTP/1.1 behaviour.
• stop_receiving_limit: breaks the read loop once that many body bytes
  have been received.
• on_progress on HTTP/2 fires per DATA payload, not per raw network read —
  documented on the field. This is the closest faithful mapping since HTTP/2's
  wire is framed and encrypted.

Tests

• test_h2_on_data_fires_per_chunk — asserts per-DATA-frame callback delivery
  with cumulative body_so_far, Content-Length, and status.
• test_h2_stop_copying_limit_caps_body_but_keeps_callback — body capped at
  the limit; callbacks fire for every chunk; body_so_far reports true totals.
• test_h2_stop_receiving_limit_breaks_early — loop breaks after the limit;
  later chunks are not delivered.

End-to-end verified against `https://www.google.com/\`:

chunk 1: 16384 bytes, body_so_far=16384, expected=0, status=200
chunk 2: 16384 bytes, body_so_far=32768, expected=0, status=200
chunk 3: 16384 bytes, body_so_far=49152, expected=0, status=200
version: HTTP/2.0  status: 200  body: 80371 bytes  callbacks fired: 5
last body_so_far=80371

`./vnew -W -cstrict -cc clang test vlib/net/http/h2_conn_test.v
vlib/net/http/h2_client_test.v` passes; the full `vlib/net/http` suite is
green (1 Windows-only skip).

🤖 Generated with Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: e7ae53cd54

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".