feat: add Redux subscriptions, selectors, and LiveView integration

Add comprehensive state change subscription system with memoized selectors
and automatic LiveView integration for reactive UIs.

New Features:
- Redux.Selector: Memoized selectors with reselect-style composition
  * create_selector/2 for composed selectors with automatic caching
  * select/2 for extracting state with memoization
  * Recursive selector composition support
  * Process-isolated caching for thread safety
  * Cache management (clear_cache/0, cache_stats/0)

- Redux.Subscription: State change notification system
  * subscribe_to_struct/3 for subscribing to state changes
  * Optional selector support for fine-grained notifications
  * Shallow equality checks to prevent unnecessary callbacks
  * Automatic notification on dispatch/time_travel/reset
  * Error handling for failing callbacks and selectors

- Redux.LiveView: LiveView integration helpers
  * assign_from_session/3 for automatic assign updates
  * subscribe_to_session/2-4 for subscribing to Redux changes
  * subscribe_to_pubsub/3 for distributed state listening
  * dispatch_to_session/2 and get_session_state/1 helpers

- Phoenix.PubSub Integration:
  * enable_pubsub/3 and disable_pubsub/1 for distributed state
  * Automatic broadcasting on dispatch when configured
  * subscribe_to_broadcasts/3 for cross-node listening

- Redux.ReduxExamples: Comprehensive usage examples
  * LiveView integration patterns
  * Phoenix Channels examples
  * Selectors and subscriptions examples
  * PubSub and distributed state examples

Enhancements:
- Redux module:
  * Add subscriptions field to Redux struct
  * Add pubsub and pubsub_topic fields
  * Add subscribe/2-3, unsubscribe/2, notify_subscriptions/1
  * Automatic subscription notification after dispatch
  * Time travel and reset now notify subscriptions
  * Enhanced documentation with comprehensive examples

- Telemetry:
  * Add 8 new Redux telemetry events:
    - [:phoenix, :session_process, :redux, :dispatch]
    - [:phoenix, :session_process, :redux, :subscribe]
    - [:phoenix, :session_process, :redux, :unsubscribe]
    - [:phoenix, :session_process, :redux, :notification]
    - [:phoenix, :session_process, :redux, :selector_cache_hit]
    - [:phoenix, :session_process, :redux, :selector_cache_miss]
    - [:phoenix, :session_process, :redux, :pubsub_broadcast]
    - [:phoenix, :session_process, :redux, :pubsub_receive]

Tests:
- Add 51 comprehensive tests across 3 test files
- Selector tests: 25 tests covering memoization, composition, cache
- Subscription tests: 18 tests covering lifecycle, notifications, errors
- Integration tests: 8 tests covering workflows, performance, recovery
- All tests passing with 100% coverage of new features

Documentation:
- Update README.md with Redux subscription/selector examples
- Update CLAUDE.md with new module descriptions
- Add comprehensive Redux.ReduxExamples module
- Add LiveView and Channels integration examples
- Document all new telemetry events

Dependencies:
- Add phoenix_pubsub ~> 2.1 for distributed state support

Breaking Changes: None

Files Changed:
- 7 new files (4 modules + 3 test files)
- 6 modified files (Redux, Telemetry, docs, mix.exs)
- +3,466 lines total

Author: GSMLG-BOT

CLAUDE.md

@@ -67,8 +67,12 @@ The library is organized into several logical groups:
 - `Phoenix.SessionProcess.DefaultSessionProcess` - Default session implementation
 
 **State Management Utilities**:
-- `Phoenix.SessionProcess.Redux` - Optional Redux-style state with actions/reducers (advanced use cases)
+- `Phoenix.SessionProcess.Redux` - Optional Redux-style state with actions/reducers, subscriptions, and selectors (advanced use cases)
+- `Phoenix.SessionProcess.Redux.Selector` - Memoized selectors for efficient derived state
+- `Phoenix.SessionProcess.Redux.Subscription` - Subscription management for reactive state changes
+- `Phoenix.SessionProcess.Redux.LiveView` - LiveView integration helpers
 - `Phoenix.SessionProcess.MigrationExamples` - Migration examples for Redux
+- `Phoenix.SessionProcess.ReduxExamples` - Comprehensive Redux usage examples
 
 **Configuration & Error Handling**:
 - `Phoenix.SessionProcess.Config` - Configuration management
@@ -109,9 +113,14 @@ The library is organized into several logical groups:
    - Runs cleanup tasks periodically
 
 6. **Phoenix.SessionProcess.Redux** (lib/phoenix/session_process/redux.ex:1)
-   - Optional Redux-style state management with actions and reducers
+   - Optional Redux-style state management with actions, reducers, subscriptions, and selectors
    - Provides time-travel debugging, middleware support, and action history
-   - Best for complex applications requiring predictable state updates and audit trails
+   - **Redux.Selector**: Memoized selectors with reselect-style composition for efficient derived state
+   - **Redux.Subscription**: Subscribe to state changes with optional selectors (only notifies when selected values change)
+   - **Redux.LiveView**: Helper module for LiveView integration with automatic assign updates
+   - **Phoenix.PubSub integration**: Broadcast state changes across nodes for distributed applications
+   - **Comprehensive telemetry**: Monitor Redux operations (dispatch, subscribe, selector cache hits/misses, PubSub broadcasts)
+   - Best for complex applications requiring reactive UIs, predictable state updates, audit trails, or distributed state
    - Note: Most applications don't need this - standard GenServer state is sufficient
 
 ### Process Management Flow

README.md

@@ -401,14 +401,184 @@ Phoenix.SessionProcess.cast("session_123", {:dispatch, {:add_to_cart, %{id: 101,
 {:ok, history} = Phoenix.SessionProcess.call("session_123", :get_history)
 ```
 
+#### Redux with Subscriptions and Selectors
+
+React to specific state changes with subscriptions and selectors:
+
+```elixir
+defmodule MyApp.ReactiveSession do
+  use Phoenix.SessionProcess, :process
+  alias Phoenix.SessionProcess.Redux
+  alias Phoenix.SessionProcess.Redux.Selector
+
+  @impl true
+  def init(_init_arg) do
+    redux = Redux.init_state(%{user: nil, cart: [], total: 0})
+
+    # Subscribe to user changes
+    redux =
+      Redux.subscribe(redux, fn state -> state.user end, fn user ->
+        IO.inspect(user, label: "User changed")
+      end)
+
+    # Subscribe with memoized selector for cart total
+    cart_total_selector =
+      Selector.create_selector(
+        [fn state -> state.cart end],
+        fn cart ->
+          Enum.reduce(cart, 0, fn item, acc -> acc + item.price end)
+        end
+      )
+
+    redux =
+      Redux.subscribe(redux, cart_total_selector, fn total ->
+        IO.inspect(total, label: "Cart total")
+      end)
+
+    {:ok, %{redux: redux}}
+  end
+
+  @impl true
+  def handle_call({:dispatch, action}, _from, state) do
+    new_redux = Redux.dispatch(state.redux, action, &reducer/2)
+    {:reply, {:ok, Redux.get_state(new_redux)}, %{state | redux: new_redux}}
+  end
+
+  defp reducer(state, action) do
+    case action do
+      {:set_user, user} -> %{state | user: user}
+      {:add_to_cart, item} -> %{state | cart: [item | state.cart]}
+      {:clear_cart} -> %{state | cart: []}
+      _ -> state
+    end
+  end
+end
+```
+
+#### Redux with LiveView
+
+Automatically update LiveView assigns from Redux state:
+
+```elixir
+defmodule MyAppWeb.ShoppingCartLive do
+  use Phoenix.LiveView
+  alias Phoenix.SessionProcess.Redux.LiveView, as: ReduxLV
+  alias Phoenix.SessionProcess.Redux.Selector
+
+  def mount(_params, %{"session_id" => session_id}, socket) do
+    if connected?(socket) do
+      # Define selectors
+      cart_count_selector = Selector.create_selector(
+        [fn state -> state.cart end],
+        fn cart -> length(cart) end
+      )
+
+      cart_total_selector = Selector.create_selector(
+        [fn state -> state.cart end],
+        fn cart -> Enum.reduce(cart, 0, &(&1.price + &2)) end
+      )
+
+      # Auto-subscribe to Redux changes
+      socket =
+        ReduxLV.assign_from_session(socket, session_id, %{
+          user: fn state -> state.user end,
+          cart_count: cart_count_selector,
+          cart_total: cart_total_selector
+        })
+
+      {:ok, assign(socket, session_id: session_id)}
+    else
+      {:ok, assign(socket, session_id: session_id, user: nil, cart_count: 0, cart_total: 0)}
+    end
+  end
+
+  # Handle automatic Redux assign updates
+  def handle_info({:redux_assign_update, key, value}, socket) do
+    {:noreply, ReduxLV.handle_assign_update(socket, key, value)}
+  end
+
+  def handle_event("add_item", %{"item" => item}, socket) do
+    ReduxLV.dispatch_to_session(socket.assigns.session_id, {:add_to_cart, item})
+    {:noreply, socket}
+  end
+
+  def render(assigns) do
+    ~H\"\"\"
+    <div>
+      <h2>Welcome, <%= @user.name %></h2>
+      <p>Cart: <%= @cart_count %> items</p>
+      <p>Total: $<%= @cart_total %></p>
+    </div>
+    \"\"\"
+  end
+end
+```
+
+#### Redux with PubSub (Distributed)
+
+Share state across nodes with Phoenix.PubSub:
+
+```elixir
+defmodule MyApp.DistributedSession do
+  use Phoenix.SessionProcess, :process
+  alias Phoenix.SessionProcess.Redux
+
+  @impl true
+  def init(arg) do
+    session_id = Keyword.get(arg, :session_id)
+
+    # Enable PubSub broadcasting
+    redux =
+      Redux.init_state(
+        %{data: %{}},
+        pubsub: MyApp.PubSub,
+        pubsub_topic: "session:\#{session_id}"
+      )
+
+    {:ok, %{redux: redux}}
+  end
+
+  @impl true
+  def handle_call({:dispatch, action}, _from, state) do
+    # Dispatch automatically broadcasts via PubSub
+    new_redux = Redux.dispatch(state.redux, action, &reducer/2)
+    {:reply, {:ok, Redux.get_state(new_redux)}, %{state | redux: new_redux}}
+  end
+
+  defp reducer(state, action) do
+    case action do
+      {:update, data} -> %{state | data: Map.merge(state.data, data)}
+      _ -> state
+    end
+  end
+end
+
+# Listen from any node
+defmodule MyApp.RemoteListener do
+  def listen(session_id) do
+    Redux.subscribe_to_broadcasts(
+      MyApp.PubSub,
+      "session:\#{session_id}",
+      fn %{action: action, state: state} ->
+        IO.inspect({action, state}, label: "Remote state change")
+      end
+    )
+  end
+end
+```
+
 **Redux Features:**
 - **Time-travel debugging** - Access complete action history
 - **Middleware support** - Add logging, validation, side effects
+- **Subscriptions** - React to specific state changes with callbacks
+- **Selectors with memoization** - Efficient derived state computation
+- **LiveView integration** - Automatic assign updates
+- **Phoenix.PubSub support** - Distributed state notifications across nodes
 - **State persistence** - Serialize and restore state
 - **Predictable updates** - All changes through explicit actions
-- **Developer tools** - Inspect actions and state changes
+- **Comprehensive telemetry** - Monitor Redux operations
 
-**Best for:** Complex applications, team collaboration, debugging requirements, state persistence needs.
+**Best for:** Complex applications, team collaboration, debugging requirements, state persistence needs, real-time reactive UIs.
 
 ### Comparison
 
@@ -451,6 +621,16 @@ The library emits comprehensive telemetry events for monitoring and debugging:
 - `[:phoenix, :session_process, :cleanup]` - When a session is cleaned up
 - `[:phoenix, :session_process, :cleanup_error]` - When cleanup fails
 
+### Redux State Management Events
+- `[:phoenix, :session_process, :redux, :dispatch]` - When a Redux action is dispatched
+- `[:phoenix, :session_process, :redux, :subscribe]` - When a subscription is created
+- `[:phoenix, :session_process, :redux, :unsubscribe]` - When a subscription is removed
+- `[:phoenix, :session_process, :redux, :notification]` - When subscriptions are notified
+- `[:phoenix, :session_process, :redux, :selector_cache_hit]` - When selector cache is hit
+- `[:phoenix, :session_process, :redux, :selector_cache_miss]` - When selector cache misses
+- `[:phoenix, :session_process, :redux, :pubsub_broadcast]` - When state is broadcast via PubSub
+- `[:phoenix, :session_process, :redux, :pubsub_receive]` - When PubSub broadcast is received
+
 ### Example Telemetry Setup
 
 ```elixir