**Apache Airflow version**:
Airflow 2.0

**Environment**:
Ubuntu 20.04 (WSL on Windows 10)

- **OS** (e.g. from /etc/os-release):
VERSION="20.04.1 LTS (Focal Fossa)"

- **Kernel** (e.g. `uname -a`):
Linux XXX 4.19.128-microsoft-standard #1 SMP Tue Jun 23 12:58:10 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

**What happened**:
After successfully running a SUBDAG, clearing it (including downstream+recursive) doesn't trigger the inner tasks. Instead, the subdag is marked successful and the inner tasks all stay cleared and aren't re-run.

**What you expected to happen**:
Expected Clear with DownStream + Recursive to re-run all subdag tasks.

<!-- What do you think went wrong? -->

**How to reproduce it**:
1. Using a slightly modified version of https://airflow.apache.org/docs/apache-airflow/stable/concepts.html#subdags:

```python
from airflow import DAG
from airflow.example_dags.subdags.subdag import subdag
from airflow.operators.dummy import DummyOperator
from airflow.operators.subdag import SubDagOperator
from airflow.utils.dates import days_ago

def subdag(parent_dag_name, child_dag_name, args):
    dag_subdag = DAG(
        dag_id=f'{parent_dag_name}.{child_dag_name}',
        default_args=args,
        start_date=days_ago(2),
        schedule_interval=None,
    )

    for i in range(5):
        DummyOperator(
            task_id='{}-task-{}'.format(child_dag_name, i + 1),
            default_args=args,
            dag=dag_subdag,
        )

    return dag_subdag
	
DAG_NAME = 'example_subdag_operator'

args = {
    'owner': 'airflow',
}

dag = DAG(
    dag_id=DAG_NAME, default_args=args, start_date=days_ago(2), schedule_interval=None, tags=['example']
)

start = DummyOperator(
    task_id='start',
    dag=dag,
)

section_1 = SubDagOperator(
    task_id='section-1',
    subdag=subdag(DAG_NAME, 'section-1', args),
    dag=dag,
)

some_other_task = DummyOperator(
    task_id='some-other-task',
    dag=dag,
)

section_2 = SubDagOperator(
    task_id='section-2',
    subdag=subdag(DAG_NAME, 'section-2', args),
    dag=dag,
)

end = DummyOperator(
    task_id='end',
    dag=dag,
)

start >> section_1 >> some_other_task >> section_2 >> end
```
2. Run the subdag fully. 
3. Clear (with recursive/downstream) any of the SubDags. 
4. The Subdag will be marked successful, but if you zoom into the subdag, you'll see all the child tasks were not run.

airflow/models/dag.py
"""
        Get the next execution date after the given ``date_last_automated_dagrun``, according to
        schedule_interval, start_date, end_date etc.  This doesn't check max active run or any other
        "concurrency" type limits, it only performs calculations based on the various date and interval fields
        of this dag and it's tasks.
        :param date_last_automated_dagrun: The execution_date of the last scheduler or
            backfill triggered run for this dag
        :type date_last_automated_dagrun: pendulum.Pendulum
        """
        if not self.schedule_interval or self.is_subdag:
            return None
        
        if self.schedule_interval == '@once' and date_last_automated_dagrun:
            return None
        
        if not (self.catchup or self.schedule_interval == '@once'):
            
            
            
            now = timezone.utcnow()
            next_start = self.following_schedule(now)
            last_start = self.previous_schedule(now)
            if next_start <= now or isinstance(self.schedule_interval, timedelta):
                new_start = last_start
            else: