Fix ChunkedBody double-encoding under Rack 3 / Rackup

Rack 2's Rack::Handler::WEBrick uses a monkey-patch on
WEBrick::HTTPResponse#setup_header that sets @Chunked = true only during
header setup (so Transfer-Encoding: chunked is emitted), then immediately
restores @Chunked = false. This means WEBrick's send_body_string sends the
response body as-is, relying on ChunkedBody to have pre-encoded it.

Rackup 2.x's WEBrick handler takes the opposite approach: it buffers the
entire body into a String, and WEBrick's []= setter permanently sets
@Chunked = true when Transfer-Encoding: chunked is assigned, so WEBrick
chunks the plain String itself. Pre-encoding with ChunkedBody under Rack 3
therefore produced double-chunked wire data that Net::HTTP decoded to raw
chunk markers instead of the actual response body.

Introduce a rack_v3? helper and guard the ChunkedBody wrapping behind it:
under Rack 3 return the plain body (callable or enumerable) and let the
server apply a single layer of chunked encoding; under Rack 2 keep the
existing ChunkedBody behaviour.

Author: orien

lib/webmachine/adapters/rack.rb

@@ -52,7 +52,7 @@ def run
           Host: application.configuration.ip
         }).merge(application.configuration.adapter_options)
 
-        if ::Rack.release.start_with?('3.')
+        if rack_v3?
           require 'rackup'
           @server = ::Rackup::Server.new(options)
         else
@@ -83,10 +83,25 @@ def call(env)
           if (io_body = IO.try_convert(response.body))
             io_body
           elsif response.body.respond_to?(:call)
-            Webmachine::ChunkedBody.new(Array(response.body.call))
+            if rack_v3?
+              # In Rack 3 the server (e.g. WEBrick via Rackup) buffers the body
+              # and applies chunked encoding itself when Transfer-Encoding is set,
+              # so we must not pre-encode with ChunkedBody.
+              [response.body.call]
+            else
+              # Rack 2's WEBrick handler sends the body as-is; ChunkedBody is
+              # required to produce valid chunked-encoded wire data.
+              Webmachine::ChunkedBody.new(Array(response.body.call))
+            end
           elsif response.body.respond_to?(:each)
-            # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
-            if response.headers[TRANSFER_ENCODING] == 'chunked'
+            if rack_v3?
+              # Return the plain enumerable. Rackup buffers it into a String then
+              # WEBrick chunks that String when Transfer-Encoding: chunked is set.
+              response.body
+            elsif response.headers[TRANSFER_ENCODING] == 'chunked'
+              # Rack 2: only pre-encode bodies that are already marked chunked;
+              # IOEncoder bodies carry their own Content-Length and must not be
+              # wrapped.
               Webmachine::ChunkedBody.new(response.body)
             else
               response.body
@@ -112,6 +127,11 @@ def base_uri(rack_req)
 
       private
 
+      # Returns true when running under Rack 3.x.
+      def rack_v3?
+        ::Rack.release.start_with?('3.')
+      end
+
       def build_webmachine_request(rack_req, headers)
         RackRequest.new(rack_req.request_method,
           rack_req.url,