### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

I'm executing a state machine using the following definition:

```json
{
  "StartAt": "Parallel",
  "States": {
    "Parallel": {
      "Type": "Parallel",
      "Next": "Unreachable",
      "Branches": [
        {
          "StartAt": "Fail",
          "States": {
            "Fail": {
              "Type": "Fail"
            }
          }
        }
      ]
    },
    "Unreachable": {
      "Type": "Pass",
      "Parameters": {
        "UnreachableOutput": true
      },
      "End": true
    }
  }
}
```

The execution is a success with the following output:

```json
{
   "UnreachableOutput": true
}
```

### Expected Behavior

The execution should fail.

On AWS executing a state machine using the provided definition results in an error. The execution should fail before reaching the state named `Unreachable` because an error occurred in one of the branches of the preceding Parallel state.

### How are you starting LocalStack?

With a docker-compose file

### Steps To Reproduce

Create and execute a state machine using the provided definition.

### Environment

```markdown
- LocalStack: 3.0.3.dev20231207105008
```


### Anything else?

_No response_
def __init__(self):
        self._worker_thread: Optional[threading.Thread] = None
        self.env_frame: Optional[Environment] = None
    def _worker_routine(self, program: Program, latch: Optional[CountDownLatch]) -> None:
        
        LOG.info(f"[ProgramWorker] [launched] [id: {self._worker_thread.native_id}]")
        program.eval(self.env_frame)
        LOG.info(f"[ProgramWorker] [terminated] [id: {self._worker_thread.native_id}]")
        self._worker_thread = None
        if latch is not None:
            latch.count_down()
    def eval(
        self, program: Program, env_frame: Environment, latch: Optional[CountDownLatch] = None
    ):
        if self._worker_thread is not None:
            raise RuntimeError("Call to ProgramWorker.eval whilst another job is running.")
        self.env_frame = env_frame
        self._worker_thread = threading.Thread(target=self._worker_routine, args=(program, latch))
        TMP_THREADS.append(self._worker_thread)
        self._worker_thread.start()
    def stop(self, stop_date: Timestamp, cause: Optional[str], error: Optional[str]) -> None:
        env = self.env_frame
        if env:
            env.set_stop(stop_date, cause, error)