Add AsyncPropsEmitter for incremental rendering

Implement AsyncPropsEmitter class to support sending async props
incrementally during streaming render. This is the first component
for Ruby-side incremental rendering support.

Features:
- call(prop_name, value) API for emitting async props
- Generates NDJSON update chunks with bundleTimestamp and updateChunk
- Creates JavaScript code to call asyncPropsManager.setProp()
- Error handling: logs errors but continues (doesn't abort render)

🤖 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/async_props_emitter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # Emitter class for sending async props incrementally during streaming render
+  # Used by stream_react_component_with_async_props helper
+  class AsyncPropsEmitter
+    def initialize(bundle_timestamp, request_stream)
+      @bundle_timestamp = bundle_timestamp
+      @request_stream = request_stream
+    end
+
+    # Public API: emit.call('propName', propValue)
+    # Sends an update chunk to the node renderer to resolve an async prop
+    def call(prop_name, prop_value)
+      update_chunk = generate_update_chunk(prop_name, prop_value)
+      @request_stream.write("#{update_chunk.to_json}\n")
+    rescue StandardError => e
+      Rails.logger.error do
+        "[ReactOnRailsPro] Failed to send async prop '#{prop_name}': #{e.message}"
+      end
+      # Continue - don't abort entire render because one prop failed
+    end
+
+    private
+
+    def generate_update_chunk(prop_name, value)
+      {
+        bundleTimestamp: @bundle_timestamp,
+        updateChunk: generate_set_prop_js(prop_name, value)
+      }
+    end
+
+    def generate_set_prop_js(prop_name, value)
+      <<~JS.strip
+        (function(){
+          var asyncPropsManager = sharedExecutionContext.get("asyncPropsManager");
+          asyncPropsManager.setProp(#{prop_name.to_json}, #{value.to_json});
+        })()
+      JS
+    end
+  end
+end

react_on_rails_pro/spec/react_on_rails_pro/async_props_emitter_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "react_on_rails_pro/async_props_emitter"
+
+RSpec.describe ReactOnRailsPro::AsyncPropsEmitter do
+  let(:bundle_timestamp) { "bundle-12345" }
+  # rubocop:disable RSpec/VerifiedDoubleReference
+  let(:request_stream) { instance_double("RequestStream") }
+  # rubocop:enable RSpec/VerifiedDoubleReference
+  let(:emitter) { described_class.new(bundle_timestamp, request_stream) }
+
+  describe "#call" do
+    it "writes NDJSON update chunk with correct structure" do
+      allow(request_stream).to receive(:write)
+
+      emitter.call("books", ["Book 1", "Book 2"])
+
+      expect(request_stream).to have_received(:write) do |output|
+        expect(output).to end_with("\n")
+        parsed = JSON.parse(output.chomp)
+        expect(parsed["bundleTimestamp"]).to eq(bundle_timestamp)
+        expect(parsed["updateChunk"]).to include('sharedExecutionContext.get("asyncPropsManager")')
+        expect(parsed["updateChunk"]).to include('asyncPropsManager.setProp("books", ["Book 1","Book 2"])')
+      end
+    end
+
+    it "logs error and continues without raising when write fails" do
+      mock_logger = instance_double(Logger)
+      allow(Rails).to receive(:logger).and_return(mock_logger)
+      allow(request_stream).to receive(:write).and_raise(StandardError.new("Connection lost"))
+      allow(mock_logger).to receive(:error)
+
+      expect { emitter.call("books", []) }.not_to raise_error
+
+      expect(mock_logger).to have_received(:error) do |&block|
+        message = block.call
+        expect(message).to include("Failed to send async prop 'books'")
+        expect(message).to include("Connection lost")
+      end
+    end
+  end
+end