Add event loop pool with process affinity for parallel execution

Event loop worker pool inspired by libuv's "one loop per thread" model.
Each loop has its own worker and maintains event ordering.

Process affinity: All tasks from the same Erlang process are routed to
the same event loop (via PID hash), guaranteeing that timers and related
async operations execute in order.

Changes:
- py_event_loop_pool.erl: Rewrite with process affinity, persistent_term
  for O(1) access, distributed task API (create_task, run, spawn_task, await)
- py_event_loop.erl: Export get_process_env/0 for pool use
- py_event_loop_pool_SUITE.erl: New test suite (9 tests)
- bench_event_loop_pool.erl: New benchmark

Configuration:
- event_loop_pool_size: Number of loops (default: schedulers count)

Benchmarks (Python 3.14, 14 schedulers):
- Sequential (pool): 150k tasks/sec (vs 83k single loop)
- Concurrent (50 procs): 164k tasks/sec
- Fire-and-collect: 417k tasks/sec

Author: benoitc

examples/bench_event_loop_pool.erl

@@ -0,0 +1,113 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+%%! -pa _build/default/lib/erlang_python/ebin
+
+%%% @doc Benchmark for event loop pool parallel processing.
+%%%
+%%% Compares single event loop vs pool performance.
+%%%
+%%% Run with:
+%%%   rebar3 compile && escript examples/bench_event_loop_pool.erl
+
+-mode(compile).
+
+main(_Args) ->
+    io:format("~n=== Event Loop Pool Benchmark ===~n~n"),
+
+    {ok, _} = application:ensure_all_started(erlang_python),
+    {ok, _} = py:start_contexts(),
+    timer:sleep(500),
+
+    print_system_info(),
+
+    %% Verify pool is ready
+    case py_event_loop_pool:get_loop() of
+        {ok, _} -> ok;
+        {error, R} ->
+            io:format("Pool not available: ~p~n", [R]),
+            halt(1)
+    end,
+
+    Stats = py_event_loop_pool:get_stats(),
+    io:format("Pool Stats: ~p~n~n", [Stats]),
+
+    %% Run benchmarks
+    bench_single_vs_pool_sequential(1000),
+    bench_pool_concurrent(20, 100),
+    bench_pool_concurrent(50, 100),
+    bench_pool_throughput(10000),
+
+    io:format("=== Benchmark Complete ===~n"),
+    halt(0).
+
+print_system_info() ->
+    io:format("System Information:~n"),
+    io:format("  Erlang/OTP: ~s~n", [erlang:system_info(otp_release)]),
+    io:format("  Schedulers: ~p~n", [erlang:system_info(schedulers)]),
+    {ok, PyVer} = py:version(),
+    io:format("  Python: ~s~n~n", [PyVer]).
+
+%% Compare single loop vs pool for sequential tasks
+bench_single_vs_pool_sequential(N) ->
+    io:format("Benchmark: Sequential tasks (single caller)~n"),
+    io:format("  Iterations: ~p~n", [N]),
+
+    %% Single event loop
+    {T1, _} = timer:tc(fun() ->
+        lists:foreach(fun(I) ->
+            Ref = py_event_loop:create_task(math, sqrt, [float(I)]),
+            {ok, _} = py_event_loop:await(Ref)
+        end, lists:seq(1, N))
+    end),
+
+    %% Pool (should be similar since same caller = same loop)
+    {T2, _} = timer:tc(fun() ->
+        lists:foreach(fun(I) ->
+            Ref = py_event_loop_pool:create_task(math, sqrt, [float(I)]),
+            {ok, _} = py_event_loop_pool:await(Ref)
+        end, lists:seq(1, N))
+    end),
+
+    io:format("  py_event_loop:     ~.2f ms (~p tasks/sec)~n",
+              [T1/1000, round(N / (T1/1000000))]),
+    io:format("  py_event_loop_pool: ~.2f ms (~p tasks/sec)~n~n",
+              [T2/1000, round(N / (T2/1000000))]).
+
+%% Pool with concurrent callers (each gets own loop = parallel)
+bench_pool_concurrent(NumProcs, TasksPerProc) ->
+    TotalTasks = NumProcs * TasksPerProc,
+    io:format("Benchmark: Concurrent callers via pool~n"),
+    io:format("  Processes: ~p, Tasks/process: ~p, Total: ~p~n",
+              [NumProcs, TasksPerProc, TotalTasks]),
+
+    Parent = self(),
+
+    {Time, _} = timer:tc(fun() ->
+        Pids = [spawn_link(fun() ->
+            lists:foreach(fun(I) ->
+                Ref = py_event_loop_pool:create_task(math, sqrt, [float(I)]),
+                {ok, _} = py_event_loop_pool:await(Ref)
+            end, lists:seq(1, TasksPerProc)),
+            Parent ! {done, self()}
+        end) || _ <- lists:seq(1, NumProcs)],
+
+        [receive {done, Pid} -> ok end || Pid <- Pids]
+    end),
+
+    io:format("  Total time: ~.2f ms~n", [Time/1000]),
+    io:format("  Throughput: ~p tasks/sec~n~n", [round(TotalTasks / (Time/1000000))]).
+
+%% High throughput test
+bench_pool_throughput(N) ->
+    io:format("Benchmark: Pool throughput (fire-and-collect)~n"),
+    io:format("  Tasks: ~p~n", [N]),
+
+    %% Submit all tasks first, then await all
+    {Time, _} = timer:tc(fun() ->
+        Refs = [py_event_loop_pool:create_task(math, sqrt, [float(I)])
+                || I <- lists:seq(1, N)],
+        [py_event_loop_pool:await(Ref) || Ref <- Refs]
+    end),
+
+    io:format("  Total time: ~.2f ms~n", [Time/1000]),
+    io:format("  Throughput: ~p tasks/sec~n~n", [round(N / (Time/1000000))]).

src/py_event_loop.erl

@@ -36,7 +36,9 @@
     spawn_task/3, spawn_task/4,
     %% Per-process namespace API
     exec/1, exec/2,
-    eval/1, eval/2
+    eval/1, eval/2,
+    %% Internal API (used by py_event_loop_pool)
+    get_process_env/0
 ]).
 
 %% gen_server callbacks