Summary

This PR optimizes the mesa_signal module by flattening the internal subscriber storage and introducing a "fast path" that bypasses the signal emission pipeline for Observable properties with no active subscribers.

Motive

When an agent updates an observable (e.g., agent.wealth = 10), the following sequence currently occurs regardless of subscriber status:

1. Lookup overhead: getattr(self, _wealth) is called to fetch the old_value. This is wasteful if no one is listening.
2. Allocation overhead: The notify() method creates a new Message object. This allocates memory for a signal payload that will immediately be discarded.
3. Function Call Overhead: self.notify(...) and self._mesa_notify(message) are called.
4. The Check: Finally, inside _mesa_notify, the system checks the dictionary.

See #3131 (comment) also.

Implementation

The optimization relies on flattening the data structure to make the subscriber check as cheap as possible

1. We changed the internal subscribers structure from a nested dictionary (dict[str, dict[str, list]]) to a flat dictionary using tuple keys (dict[tuple[str, str], list]). This reduces pointer chasing and simplifies the lookup logic.

2. Added a helper method _has_subscribers that utilizes the new flat structure to check for listeners in a single step:

def _has_subscribers(self, name: str, signal_type: str | SignalType) -> bool:
    # Single tuple key lookup
    key = (name, signal_type)
    if key not in self.subscribers:
        return False
    return len(self.subscribers[key]) > 0

3. Updated BaseObservable.__set__ to check _has_subscribers immediately. If it returns False, the method exits early, skipping getattr, Message allocation, and notification calls.

def __set__(self, instance: HasObservables, value):
    # Early exit if no one is listening
    if not instance._has_subscribers(self.public_name, SignalType.CHANGE):
        return

    instance.notify(
        self.public_name,
        getattr(instance, self.private_name, self.fallback_value),
        value,
        SignalType.CHANGE,
    )