fed-sx-m2: Step 1b — nx_kernel multi-actor gen_server calls + 9 tests

New gen_server exports add_actor/3, publish_to/2, log_tip_for/1,
actors/0, state_for/1, bucket_for/1, with_projections_for/2 —
each is a thin gen_server:call delegating to 1a's pure-functional
bucket API via fresh handle_call branches. Existing single-actor
calls (publish/1, log_tip/0, with_projections/1) route through
bucket 0 unchanged.

Per-actor mailbox sharding (one gen_server per bucket so distinct-
actor publishes don't serialise on a single mailbox) is forward-
looking — deferred to Step 4 where the per-actor HTTP routing makes
it actually load-bearing. Single-mailbox serialisation is fine for
Steps 1-3.

nx_kernel_multi.sh extended from 17 to 26 cases (gen_server load,
start_link bucket-0 seed, add_actor/3 dup detection, publish_to/2
per-actor isolation, interleaved publishes, no_actor error, state_for
+ with_projections_for round-trips). 134/134 across 12 nx_kernel-
adjacent + http suites. Erlang conformance 761/761 preserved.

next/kernel/nx_kernel.erl

@@ -15,7 +15,10 @@
 
 %% gen_server API
 -export([start_link/3, publish/1, query/0, log_tip/0,
-         with_projections/1, stop/0]).
+         with_projections/1, stop/0,
+         add_actor/3, publish_to/2, log_tip_for/1,
+         actors/0, state_for/1, bucket_for/1,
+         with_projections_for/2]).
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2]).
 
 %% Kernel orchestrator — the long-lived runtime state held by the
@@ -242,9 +245,11 @@ set(K, V, [P | Rest]) -> [P | set(K, V, Rest)].
 %% macro, spawned processes don't persist across separate
 %% erlang-eval-ast calls — tests inline start_link with operations.
 %%
-%% Step 1a (m2) keeps the gen_server single-actor; multi-actor
-%% gen_server calls (publish_to/2, log_tip_for/1, ...) land in
-%% iteration 1b.
+%% Step 1b (m2) adds multi-actor gen_server calls:
+%% add_actor/3, publish_to/2, log_tip_for/1, actors/0, state_for/1,
+%% with_projections_for/2 — all delegating to the pure-functional
+%% bucket APIs. Existing single-actor calls (publish/1, log_tip/0,
+%% with_projections/1) continue to route through bucket 0.
 
 start_link(ActorId, KeySpec, ActorStateProplist) ->
     Pid = gen_server:start_link(nx_kernel,
@@ -269,6 +274,29 @@ log_tip() ->
 with_projections(Names) ->
     gen_server:call(nx_kernel, {set_projections, Names}).
 
+%% Step 1b — multi-actor gen_server calls.
+
+add_actor(ActorId, KeySpec, AS) ->
+    gen_server:call(nx_kernel, {add_actor, ActorId, KeySpec, AS}).
+
+publish_to(ActorId, Request) ->
+    gen_server:call(nx_kernel, {publish_to, ActorId, Request}).
+
+log_tip_for(ActorId) ->
+    gen_server:call(nx_kernel, {log_tip_for, ActorId}).
+
+actors() ->
+    gen_server:call(nx_kernel, get_actors).
+
+state_for(ActorId) ->
+    gen_server:call(nx_kernel, {state_for, ActorId}).
+
+bucket_for(ActorId) ->
+    gen_server:call(nx_kernel, {bucket_for, ActorId}).
+
+with_projections_for(ActorId, Names) ->
+    gen_server:call(nx_kernel, {set_projections_for, ActorId, Names}).
+
 %% gen_server callbacks
 
 init([ActorId, KeySpec, AS]) ->
@@ -286,7 +314,30 @@ handle_call(get_state, _From, State) ->
 handle_call(get_log_tip, _From, State) ->
     {reply, log_tip(State), State};
 handle_call({set_projections, Names}, _From, State) ->
-    {reply, ok, with_projections(Names, State)}.
+    {reply, ok, with_projections(Names, State)};
+handle_call({add_actor, ActorId, KeySpec, AS}, _From, State) ->
+    case add_actor(ActorId, KeySpec, AS, State) of
+        {ok, NewState}      -> {reply, ok, NewState};
+        {error, Reason}     -> {reply, {error, Reason}, State}
+    end;
+handle_call({publish_to, ActorId, Request}, _From, State) ->
+    case publish(ActorId, Request, State) of
+        {ok, Result, NewState}      -> {reply, {ok, Result}, NewState};
+        {error, Reason, SameState}  -> {reply, {error, Reason}, SameState}
+    end;
+handle_call({log_tip_for, ActorId}, _From, State) ->
+    {reply, actor_log_tip(ActorId, State), State};
+handle_call(get_actors, _From, State) ->
+    {reply, actors(State), State};
+handle_call({state_for, ActorId}, _From, State) ->
+    {reply, actor_state(ActorId, State), State};
+handle_call({bucket_for, ActorId}, _From, State) ->
+    {reply, actor_bucket(ActorId, State), State};
+handle_call({set_projections_for, ActorId, Names}, _From, State) ->
+    case with_actor_projections(ActorId, Names, State) of
+        {ok, NewState}      -> {reply, ok, NewState};
+        {error, Reason}     -> {reply, {error, Reason}, State}
+    end.
 
 handle_cast(_, S) -> {noreply, S}.