feat(quic,http): implement QUIC FIN signaling, HTTP/1 body limit, and review fixes

QUIC FIN layer:
- Add NGTCP2_WRITE_STREAM_FLAG_FIN/MORE constants and flags parameter
  to conn_writev_stream
- Register recv_stream_data and stream_close ngtcp2 callbacks with
  FIN detection and overflow-safe event buffering
- Add send_fin(), send_with_fin(), send_with_flags() methods
- Add drain_stream_events() with error propagation on overflow
- Add ensure_stream(), stream_has_fin(), stream_exists() abstraction API
- Auto-create stream entries for FIN events on unknown streams

HTTP/3 FIN integration:
- Replace non-standard empty DATA frame end-marker with proper QUIC
  FIN signaling per RFC 9114 §4.1
- Client sends FIN after last frame via send_frame_with_fin()
- Server detects request completion via check_fin_completions() sweep
  after frame processing, handling separate-packet FIN and empty-body
  POST/PUT/PATCH
- Server coalesces response FIN with last data write
- Per-connection packet_mu mutex serializing QUIC state mutations
- Split process_packet_frames into ingest/decode/dispatch helpers

HTTP/1 hardening:
- Add max_request_body_size (10MB default) to Server struct matching
  HTTP/2 and HTTP/3 defaults
- Add parse_request_with_limit() checking Content-Length before allocation
- Strict Content-Length validation rejecting negative, non-numeric, and
  overflow values via validate_and_parse_content_length()
- Detect truncated request bodies (unexpected EOF)
- Backward-compatible Handler interface with ServerHandler adapter

Author: jupilhwang

.gitignore

@@ -169,4 +169,7 @@ autofuzz.log
 CHANGELOG.md
 v
 vnew
-vnew.*
+vnew.*
+
+docs/
+*.md

examples/binary_upload_server.v

@@ -0,0 +1,88 @@
+// Binary Upload/Download Server Example
+// Demonstrates []u8 body handling for file uploads and binary responses.
+module main
+
+import net.http
+import os
+
+struct BinaryHandler {}
+
+fn (h BinaryHandler) handle(req http.ServerRequest) http.ServerResponse {
+	match req.path {
+		'/upload' {
+			if req.method != .post {
+				return http.ServerResponse{
+					status_code: 405
+					body:        'Method Not Allowed'.bytes()
+				}
+			}
+			content_type := req.header.get(.content_type) or { 'application/octet-stream' }
+			println('[upload] received ${req.body.len} bytes (${content_type})')
+
+			os.write_file_array('/tmp/uploaded_file', req.body) or {
+				return http.ServerResponse{
+					status_code: 500
+					body:        'Failed to save file: ${err}'.bytes()
+				}
+			}
+
+			mut header := http.new_header()
+			header.add(.content_type, 'application/json')
+			return http.ServerResponse{
+				status_code: 200
+				header:      header
+				body:        '{"status":"ok","size":${req.body.len}}'.bytes()
+			}
+		}
+		'/download' {
+			data := os.read_bytes('/tmp/uploaded_file') or {
+				return http.ServerResponse{
+					status_code: 404
+					body:        'No file uploaded yet'.bytes()
+				}
+			}
+			mut header := http.new_header()
+			header.add(.content_type, 'application/octet-stream')
+			header.add(.content_disposition, 'attachment; filename="downloaded_file"')
+			return http.ServerResponse{
+				status_code: 200
+				header:      header
+				body:        data
+			}
+		}
+		'/generate' {
+			size := 1024 * 1024 // 1 MB of binary data
+			mut data := []u8{len: size}
+			for i in 0 .. size {
+				data[i] = u8(i % 256)
+			}
+			mut header := http.new_header()
+			header.add(.content_type, 'application/octet-stream')
+			return http.ServerResponse{
+				status_code: 200
+				header:      header
+				body:        data
+			}
+		}
+		'/' {
+			return http.ServerResponse{
+				status_code: 200
+				body:        'Binary Server\n\nEndpoints:\n  POST /upload   - upload binary file\n  GET  /download - download last uploaded file\n  GET  /generate - download 1MB generated binary\n'.bytes()
+			}
+		}
+		else {
+			return http.ServerResponse{
+				status_code: 404
+				body:        'Not found'.bytes()
+			}
+		}
+	}
+}
+
+fn main() {
+	mut server := http.Server{
+		addr:    ':8080'
+		handler: BinaryHandler{}
+	}
+	server.listen_and_serve()
+}

examples/http2/01_simple_server.v

@@ -1,71 +1,75 @@
-// Simple HTTP/2 Server Example
-// Demonstrates basic HTTP/2 server usage
-import net.http.v2
+// HTTP/2 Server Example
+// Demonstrates HTTP/2 server using the unified net.http API.
+// HTTP/2 is enabled automatically over TLS with ALPN h2 negotiation.
+//
+// To generate test certificates:
+//   openssl req -x509 -newkey rsa:2048 -nodes \
+//     -keyout cert.pem -out cert.pem -days 365 \
+//     -subj "/CN=localhost"
+//
+// Test with: curl -k --http2 https://localhost:8080/
+module main
 
-fn main() {
-	// Create server configuration
-	config := v2.ServerConfig{
-		addr:                   '0.0.0.0:8080'
-		max_concurrent_streams: 100
-		initial_window_size:    65535
-		max_frame_size:         16384
-	}
-
-	// Create server with handler
-	mut server := v2.new_server(config, handle_request) or {
-		eprintln('Failed to create server: ${err}')
-		return
-	}
+import net.http
 
-	println('Starting HTTP/2 server on ${config.addr}')
-	println('Test with: curl --http2-prior-knowledge http://localhost:8080/')
-	println('Press Ctrl+C to stop')
-
-	// Start server (blocks)
-	server.listen_and_serve() or { eprintln('Server error: ${err}') }
-}
+struct AppHandler {}
 
-// handle_request processes HTTP/2 requests
-fn handle_request(req v2.ServerRequest) v2.ServerResponse {
-	println('Received: ${req.method} ${req.path}')
+fn (h AppHandler) handle(req http.ServerRequest) http.ServerResponse {
+	println('Received: ${req.method} ${req.path} (${req.version})')
 
-	// Route requests
 	match req.path {
 		'/' {
-			return v2.ServerResponse{
+			return http.ServerResponse{
 				status_code: 200
-				headers:     {
-					'content-type': 'text/html; charset=utf-8'
-				}
+				header:      http.new_header_from_map({
+					.content_type: 'text/html; charset=utf-8'
+				})
 				body:        '<h1>Hello from HTTP/2!</h1><p>This is a V HTTP/2 server.</p>'.bytes()
 			}
 		}
 		'/json' {
-			return v2.ServerResponse{
+			return http.ServerResponse{
 				status_code: 200
-				headers:     {
-					'content-type': 'application/json'
-				}
+				header:      http.new_header_from_map({
+					.content_type: 'application/json'
+				})
 				body:        '{"message":"Hello from HTTP/2","protocol":"h2"}'.bytes()
 			}
 		}
 		'/echo' {
-			return v2.ServerResponse{
+			return http.ServerResponse{
 				status_code: 200
-				headers:     {
-					'content-type': 'text/plain'
-				}
-				body:        'Method: ${req.method}\nPath: ${req.path}\n'.bytes()
+				header:      http.new_header_from_map({
+					.content_type: 'text/plain'
+				})
+				body:        'Method: ${req.method}\nPath: ${req.path}\nVersion: ${req.version}\n'.bytes()
 			}
 		}
 		else {
-			return v2.ServerResponse{
+			return http.ServerResponse{
 				status_code: 404
-				headers:     {
-					'content-type': 'text/plain'
-				}
+				header:      http.new_header_from_map({
+					.content_type: 'text/plain'
+				})
 				body:        'Not Found'.bytes()
 			}
 		}
 	}
 }
+
+fn main() {
+	mut server := http.Server{
+		addr:      '0.0.0.0:8080'
+		handler:   AppHandler{}
+		cert_file: 'cert.pem'
+		key_file:  'key.pem'
+	}
+
+	println('Starting HTTP/2 server on ${server.addr}')
+	println('HTTP/2 is enabled automatically over TLS (ALPN h2)')
+	println('Test with: curl -k --http2 https://localhost:8080/')
+	println('Press Ctrl+C to stop')
+
+	// listen_and_serve_tls() starts HTTP/2 over TLS automatically
+	server.listen_and_serve_tls() or { eprintln('Server error: ${err}') }
+}