Personally I dislike a self-serve approach, IMHO it's much more difficult to manage reliably distribution of tasks among nodes with a distributed intelligence since the local logic doesn't have the global view of the system for its decisions. Redistributing entities when new nodes are added is just one example.
The apparent system scalability which might have been the reason for choosing such approach is just an illusion - the need for the centralized ownership registry is an indicator of that, managing it reliably in a distributed manner is no trivial task, glitches would cause jobs stuck/forgotten/lost. Error recovery is difficult, the centralized manager node is still required since the local intelligence may dissapear.
Since you mentioned that
once an entity is assigned to particular node, it is taken to
completion through that node only
the key to allow new nodes to pick up part of the overall load is to not distribute entities to nodes until they are able to immediately start and complete their processing confortably within their load capabilities. In other words don't create local waiting queues for each node as entities may be waiting there while other nodes could easily process them immediately. And don't overload nodes just to keep the waiting times small. Keeping the entities unassigned makes them available for any node to pick up - a single waiting queue for the system.
As for balancing the load across nodes it's important to reflect the node's load in the local distribution logic. One way of achieving it without precisely knowing the loads of all the other nodes in the system is to "encode" the local node's load in the waiting queue polling rate.
For example, a node which already has 3 entities assigned would check for available entities once every 3 seconds, while a node with 10 entities assigned would poll only once every 10 seconds. This allows nodes with lighter loads to pick up entities faster, thus catching up with the other nodes - a newly added node would be able to pick up 4 entities in the same interval in which a node already processing 10 entities could only pick up one. The overall system's load would thus automatically be balanced across all available nodes (when all nodes reach the same polling rate).