Fix HTTPX thread-safety issue with thread-local connections for incremental rendering

Problem:
The HTTPX stream_bidi plugin has a critical limitation - only the thread that creates
the bidirectional streaming connection can write chunks to the request stream. This
causes race conditions in multi-threaded production environments (e.g., Puma) where
different HTTP requests run on different threads.

When the first request creates a connection on Thread A and stores it in an instance
variable, subsequent requests on Thread B cannot write to that connection, causing
connection errors and unpredictable behavior.

Solution:
Implement thread-local storage for incremental rendering connections. Each thread now
gets its own persistent bidirectional streaming connection stored in Thread.current
instead of a shared instance variable.

Changes:
- Modified `incremental_connection` to use `Thread.current[:react_on_rails_incremental_connection]`
- Added `reset_thread_local_incremental_connections` to properly clean up all thread-local connections
- Updated `reset_connection` to call the new cleanup method
- Removed `@incremental_connection` instance variable

Trade-offs:
- ✅ Eliminates race conditions and thread-safety issues
- ✅ Simple implementation using Ruby's built-in thread-local storage
- ✅ Each thread has isolated, persistent connection
- ⚠️  Higher memory usage (one connection per Puma worker thread)
- ⚠️  Not optimal for high-scale production with many threads

This is a temporary solution. Long-term options:
1. Fix HTTPX to support multi-threaded bidirectional streaming
2. Migrate to async-http gem which is thread-safe by design

Fixes #2115

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

Co-Authored-By: Claude <[email protected]>

Author: AbanoubGhadban

react_on_rails_pro/lib/react_on_rails_pro/request.rb

@@ -10,9 +10,8 @@ class Request # rubocop:disable Metrics/ClassLength
     class << self
       def reset_connection
         @standard_connection&.close
-        @incremental_connection&.close
         @standard_connection = nil
-        @incremental_connection = nil
+        reset_thread_local_incremental_connections
       end
 
       def render_code(path, js_code, send_bundle)
@@ -135,8 +134,19 @@ def connection
       end
       # rubocop:enable Naming/MemoizedInstanceVariableName
 
+      # Thread-local connection for incremental rendering
+      # Each thread gets its own persistent connection to avoid connection pool issues
       def incremental_connection
-        @incremental_connection ||= create_incremental_connection
+        Thread.current[:react_on_rails_incremental_connection] ||= create_incremental_connection
+      end
+
+      def reset_thread_local_incremental_connections
+        # Close all thread-local incremental connections
+        Thread.list.each do |thread|
+          conn = thread[:react_on_rails_incremental_connection]
+          conn&.close
+          thread[:react_on_rails_incremental_connection] = nil
+        end
       end
 
       def perform_request(path, **post_options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity