### Summary

I have a playbook that drivers a cluster software upgrade. Because I need to ensure that all hosts belonging to the cluster will be upgraded, I have set `any_errors_fatal=yes` at play level. Also, in order to perform on-the-fly fixes for any issue raised during the playbook execution, I also have set `debugger=on_failure` at play level.

One of the upgrade steps requires an action to be performed in a single node of the cluster, so on that particular task, I defined `run_once=yes`.

However, under the combination of `any_errors_fatal=yes`, `debugger=on_failure` and `run_once=yes`, Ansible is not reactivating hosts that were active when a task intended to run only once faiis and is repeated. Instead, only the host where the task is executed comes back to to the list active hosts. As a consequence, if the debugger is invoked, the cluster software upgrade becomes incomplete.

### Issue Type

Bug Report

### Component Name

lib/ansible/plugins/strategy/__init__.py

### Ansible Version

```console
$ ansible --version
ansible [core 2.11.5] 
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/amg1127/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3.9/site-packages/ansible
  ansible collection location = /home/amg1127/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.9.7 (default, Aug 31 2021, 13:28:12) [GCC 11.1.0]
  jinja version = 3.0.2
  libyaml = True
```


### Configuration

```console
$ ansible-config dump --only-changed
# (blank output) #
```


### OS / Environment

Arch Linux

### Steps to Reproduce

Please store the below content as `inventory.yml`:

```yaml (paste below)
---
all:
  hosts:
    host1:
      ansible_connection: local
    host2:
      ansible_connection: local
```
And store the below content as `playbook.yml`:

```yaml (paste below)
---
- hosts: all
  gather_facts: no
  debugger: on_failed
  any_errors_fatal: yes
  tasks:

    - name: Task 1
      debug:
        var: inventory_hostname

    - name: Task 2
      assert:
        that: 'false'
      run_once: yes

    - name: Task 3
      debug:
        var: inventory_hostname
```

Run this command line: `ansible-playbook -i inventory.yml playbook.yml`

Once the Ansible debugger is invoked after the `Task 2` failure, update the `that` argument for the `assert` module so that the evaluation is always `true`. Afterwards, redo the failed task.

```
(debug)> task.args['that'] = 'true'
(debug)> r
```

### Expected Results

I expected `host2` to execute `Task 3` after the successful execution of `Task 2`.

```
PLAY [all] *************************************************************************************************************

TASK [Task 1] **********************************************************************************************************
ok: [host1] => {
    "inventory_hostname": "host1"
}
ok: [host2] => {
    "inventory_hostname": "host2"
}

TASK [Task 2] **********************************************************************************************************
fatal: [host1]: FAILED! => {
    "assertion": "false",
    "changed": false,
    "evaluated_to": false,
    "msg": "Assertion failed"
}
[host1] TASK: Task 2 (debug)> task.args['that'] = 'true'
[host1] TASK: Task 2 (debug)> r
ok: [host1] => {
    "changed": false,
    "msg": "All assertions passed"
}

TASK [Task 3] **********************************************************************************************************
ok: [host1] => {
    "inventory_hostname": "host1"
}
ok: [host2] => {
    "inventory_hostname": "host2"
}

PLAY RECAP *************************************************************************************************************
host1                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
host2                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
```

### Actual Results

```console
PLAY [all] *************************************************************************************************************

TASK [Task 1] **********************************************************************************************************
ok: [host1] => {
    "inventory_hostname": "host1"
}
ok: [host2] => {
    "inventory_hostname": "host2"
}

TASK [Task 2] **********************************************************************************************************
fatal: [host1]: FAILED! => {
    "assertion": "false",
    "changed": false,
    "evaluated_to": false,
    "msg": "Assertion failed"
}
[host1] TASK: Task 2 (debug)> task.args['that'] = 'true'
[host1] TASK: Task 2 (debug)> r
ok: [host1] => {
    "changed": false,
    "msg": "All assertions passed"
}

TASK [Task 3] **********************************************************************************************************
ok: [host1] => {
    "inventory_hostname": "host1"
}

PLAY RECAP *************************************************************************************************************
host1                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
host2                      : ok=1    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
```


### Code of Conduct

- [X] I agree to follow the Ansible Code of Conduct
for sock in self._active_connections.values():
            try:
                conn = Connection(sock)
                conn.reset()
            except ConnectionError as e:
                
                display.debug("got an error while closing persistent connection: %s" % e)
        self._final_q.put(_sentinel)
        self._results_thread.join()
    def run(self, iterator, play_context, result=0):
        
        
        
        
        for host in self._hosts_cache:
            if host not in self._tqm._unreachable_hosts:
                try:
                    iterator.get_next_task_for_host(self._inventory.hosts[host])