Single event notification is being yielded every time with `wait_for_external_event`

🐛 **Describe the bug**
When an event notification is raised for an orchestrator that is not yet waiting, then using `wait_for_external_event` multiple times will always yield that same specific initial event.

A typical scenario when this might happen is when multiple event notifications are raised at the same time by other orchestrators and the main orchestrator would not be waiting during handling of the first event.

🤔 **Expected behavior**
The expected behavior is that a single event notification only yields a single `wait_for_external_event`. This does work as expected for event notifications that were submitted _after_ an orchestrator already started to wait for the external event, but not for notification events that were scheduled _before_ waiting for the external event.

☕ **Steps to reproduce**

I have been able to reproduce the issue in a small example as seen below.

Sample repository: https://github.com/arjendev/durable-functions-python-external-events-issue-sample
Sample orchestration history: https://github.com/arjendev/durable-functions-python-external-events-issue-sample/blob/main/OrchestrationHistory.csv

```python
myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@myApp.route(route="orchestrators/{functionName}")
@myApp.durable_client_input(client_name="client")
async def http_start(req: func.HttpRequest, client: DurableOrchestrationClient):
function_name = req.route_params.get('functionName')
instance_id = await client.start_new(function_name)
response = client.create_check_status_response(req, instance_id)
return response

# Orchestrator
@myApp.orchestration_trigger(context_name="context")
def hello_orchestrator(context: DurableOrchestrationContext):
yield context.call_activity("raise_my_durable_event", context.instance_id)
while True:
yield context.wait_for_external_event("my-durable-event")

# Activity
@myApp.activity_trigger(input_name="instance", activity="raise_my_durable_event")
@myApp.durable_client_input(client_name="client")
async def raise_my_durable_event(client: DurableOrchestrationClient, instance):
await client.raise_event(instance, "my-durable-event")
```

The expected behavior of execution of the orchestrator would be:
1. Start the orchestrator through the http_trigger
2. Main orchestrator starts and raises an event notification with name: `my-durable-event`
3. Main orchestrator enters the while loop and starts waiting for external events and immediately yields the already scheduled event notification
4. Main orchestrator halts in the second iteration of the while loop and waits for future events

However, on step 4, the `wait_for_external_event` keeps returning the initial event and thus the while loop runs forever with the eventual error: `Orchestrator function 'hello_orchestrator' failed: maximum recursion depth exceeded in comparison`.

Start with the wait_for_external_event entry point and reproduce the behavior using the linked sample repository and OrchestrationHistory.csv. Verify that an event raised before waiting is consumed once, that the second wait blocks for a future event, and that the orchestrator no longer recurses until the maximum recursion depth is exceeded.

Vom Indexierungsmodell aus dem Issue-Text verfasst.