**Apache Airflow version**: 2.0.1
**Kubernetes version**: v1.19.7
**Executor**: KubernetesExecutor

**What happened**:

If you have a worker that gets stuck in pending forever, say with a missing volume mount, the task will stay in the queued state forever. Nothing is applying a timeout on it actually being able to start.

**What you expected to happen**:

Eventually the scheduler will notice that the worker hasn't progressed past pending after a given amount of time and will mark it as a failure.

**How to reproduce it**:
```python
from airflow import DAG
from airflow.operators.bash import BashOperator
from airflow.utils.dates import days_ago
from kubernetes.client import models as k8s


default_args = {
    "owner": "airflow",
}

with DAG(
    dag_id="pending",
    default_args=default_args,
    schedule_interval=None,
    start_date=days_ago(2),
) as dag:
    BashOperator(
        task_id="forever_pending",
        bash_command="date; sleep 30; date",
        executor_config={
            "pod_override": k8s.V1Pod(
                spec=k8s.V1PodSpec(
                    containers=[
                        k8s.V1Container(
                            name="base",
                            volume_mounts=[
                                k8s.V1VolumeMount(mount_path="/foo/", name="vol")
                            ],
                        )
                    ],
                    volumes=[
                        k8s.V1Volume(
                            name="vol",
                            persistent_volume_claim=k8s.V1PersistentVolumeClaimVolumeSource(
                                claim_name="missing"
                            ),
                        )
                    ],
                )
            ),
        },
    )
```


**Anything else we need to know**:
Related to:

* #15149 (This is reporting that these pending pods don't get deleted via "Mark Failed")
* #14556 (This handles when these pending pods get deleted and is already fixed)

airflow/jobs/scheduler_job.py
"""
    Process a Python file containing Airflow DAGs.
    This includes:
    1. Execute the file and look for DAG objects in the namespace.
    2. Execute any Callbacks if passed to DagFileProcessor.process_file
    3. Serialize the DAGs and save it to DB (or update existing record in the DB).
    4. Pickle the DAG and save it to the DB (if necessary).
    5. Record any errors importing the file into ORM
    Returns a tuple of 'number of dags found' and 'the count of import errors'
    :param dag_ids: If specified, only look at these DAG ID's
    :type dag_ids: List[str]
    :param log: Logger to save the processing process
    :type log: logging.Logger
    """
    UNIT_TEST_MODE: bool = conf.getboolean('core', 'UNIT_TEST_MODE')
    def __init__(self, dag_ids: Optional[List[str]], log: logging.Logger):