**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
self._concurrency = value
    @property
    def access_control(self):
        return self._access_control
    @access_control.setter
    def access_control(self, value):
        self._access_control = DAG._upgrade_outdated_dag_access_control(value)
    @property
    def description(self) -> Optional[str]:
        return self._description
    @property
    def default_view(self) -> str:
        return self._default_view
    @property
    def pickle_id(self) -> Optional[int]:
        return self._pickle_id
    @pickle_id.setter
    def pickle_id(self, value: int) -> None:
        self._pickle_id = value
    def param(self, name: str, default=None) -> DagParam:
        """
        Return a DagParam object for current dag.
        :param name: dag parameter name.
        :param default: fallback value for dag parameter.
        :return: DagParam instance for specified name and current dag.
        """
        return DagParam(current_dag=self, name=name, default=default)
    @property
    def tasks(self) -> List[BaseOperator]: