Making something Erlang-compliant is actually fairly heavy duty. It's more than just "you've got actors, I've got actors, let's play together!"... you have to support the Erlang term format specifically, so on the Rust side you would need to be able to convert to and from all the state you actually want into Erlang terms, including PID references, you need to support Erlang's linking capability, you need to support Erlang's name server lookups, you need to support Erlang's specific messaging semantics for out-of-order message handling and mailboxes, binary sharing, probably some other things I'm not remembering. It's not an impossible amount of work but it's not in the "couple of weeks of spare time for a motivated developer" range either.
Most people most of the time are just better hooking up one of the many, many other event busses that both Rust and Erlang can speak to and working across that.
1. assuming a running process pA on nodeA, registered in a cluster-level process registry by name N;
2. send the process pA's state to a function on node B, which will use it to start a process pB on node B that is a clone of pA;
3. update the cluster-level process registry to point N at pB.
4. if you want to be really clever — tail-call (or code-upgrade) pA out of its existing loop, into code that makes pA act as a proxy for pB, so that anything sending a message to pA ends up talking to pB through pA.
But this isn't "sending a process"; pA itself remains "stuck" on nodeA (node IDs are actually embedded in PIDs!), and there's especially no native mechanism that would do things like rewrite the links/monitors on other processes that currently point to pA, to instead point to pB (so if pA was a supervisor, you couldn't "re-parent" the children of pA over to pB.)
I actually have a side project doing this. I mapped an actor Id in ractor to a PID in erlang and used a rust create to implement the network protocol for erlang. I ran out of time on this side project kind of deal but it's like 90% there and can do a full cluster join and send and receive messages between remote actors on nodes.
The crate that helped this is erl_dist. I'd love to open source the code at some point, but it's not quite there yet
Most people most of the time are just better hooking up one of the many, many other event busses that both Rust and Erlang can speak to and working across that.