Summary

This PR implements the first phase of the unified time and event scheduling API discussed in #2921. It integrates event scheduling directly into the Model class, making it simple to use both traditional time-stepping and discrete event simulation without breaking any existing functionality.

Basically, this PR does two things:

1. Introduce a nicer API for DEVS
2. Letting Model.step() run the model for 1 timestep

Motivation

Currently, users who want to use event scheduling must work with the experimental Simulator classes (ABMSimulator, DEVSimulator), which requires managing two separate objects and understanding the distinction between them. This creates unnecessary complexity for a feature that should be a natural part of Mesa models.

This PR makes event scheduling a first-class citizen by integrating it directly into Model, while maintaining full backward compatibility with existing step-based models.

Usage patterns

This API enables classical ABM, pure event-driven, and hybrid stuff in between. I think

1. Pure classical ABM

Everything happens in step(), time advances in integer increments:

class WolfSheep(Model):
    def step(self):
        self.agents.shuffle_do("step")

model = WolfSheep()
for _ in range(100):
    model.step()  # t=1, 2, 3, ...

This is what most people who don't use a simulator do now.

2. Hybrid: step + events

Regular stepping with scheduled one-off or agent-triggered events:

class WolfSheep(Model):
    def __init__(self):
        super().__init__()
        self.schedule_at(self.drought, time=50)  # One-off event
    
    def step(self):
        self.agents.shuffle_do("step")
    
    def drought(self):
        self.grass_layer.modify_cells(lambda g: g * 0.5)

model = WolfSheep()
for _ in range(100):
    model.step()  # step() at t=1,2,3... + drought fires at t=50

This is functionally equivalent to the ABMScheduler, but you still call model.step(). So instead of a scheduler scheduling the step, this works the other way around, the step run the scheduled events (if any).

3. Pure event-driven (no step)

No regular stepping, only scheduled events with continuous time:

class QueueingModel(Model):
    def __init__(self, arrival_rate):
        super().__init__()
        self.arrival_rate = arrival_rate
        self.schedule_at(self.customer_arrival, time=0)
    
    def customer_arrival(self):
        Customer(self)
        next_time = self.time + self.random.expovariate(self.arrival_rate)
        self.schedule_at(self.customer_arrival, time=next_time)

model = QueueingModel(arrival_rate=2.0)
model.run_until(1000.0)  # Time jumps between events: t=0, 0.3, 0.8, 1.2, ...

This is functionally equivalent to the DEVScheduler.

This PR is fully backward compatible. Users can opt-in to new features without modifying existing code.

Curious what everybody thinks of this approach. Being backwards compatible has a lot going for it, as well as the easy intro into scheduling events.

The only disadvantage might be that users could expect the run() methods to also perform the step. But I think we can explain that.

We could optionally add a run_steps() utility method:

def run_steps(self, n_steps):
    """Run n steps using the step() method."""
    for _ in range(n_steps):
        self.step()

If we agree on this direction, I will add/update tests, the simulator, example models and the tutorial.

Part of #2921.