I've not thought it through in detail, but I envisage a forward_message method on your CDAT object that disallows recursive calls with the same message object. Consider:

sub forward_message {
    my ($self, $message) = @_;

    return undef if exists $self->{activeMessages}{$message->id_hash};

    $self->{activeMessages}{$message->id_hash} = 1;
    # forward messages to all objects. Objects determine applicability

    delete $self->{activeMessages}{$message->{id_hash}};
    return 1;
}
[download]

Note that both CDAT and the message are objects and retain state. Messages may trigger the immediate processing of more messages, but reprocessing "identical" messages is prohibited. The id_hash determines what is considered to be "identical".

The idea of dynamic dispatch appeals to me for this application so I'd likely have a chunk of code in the target objects's message handlers that looks like:

sub message_handler {
    my ($self, $message) = @_
    my $handler = 'handler_' . $message->{action};

    return undef if ! $self->can ($handler);
    return $self->$handler ($message);
}

sub handler_addTaxonName {
    my ($self, $message) = @_;
    my $newTaxon = $message->{newTaxon};

    ...

    my $balance = $self->create_message ('rebalance', -taxon => $newTa
+xon, ...);

    $self->{CDAT}->forward_message ($balance);
    return 1;
}

sub handler_rebalance {
    my ($self, $message) = @_;
    my $newTaxon = $message->{newTaxon};

    ...
}
[download]