**Apache Airflow version**: v2.0.0 and up
**Kubernetes version (if you are using kubernetes)** (use `kubectl version`): not tested with K8
**Environment**:
all

**What happened**:

Executing the unit test included below, or create an infinite pool ( `-1` slots ) and tasks that should be executed in that pool.
```
INFO     airflow.jobs.scheduler_job.SchedulerJob:scheduler_job.py:991 Not scheduling since there are -1 open slots in pool test_scheduler_verify_infinite_pool
```

**What you expected to happen**:

To schedule tasks, or to drop support for infinite slots pools?

**How to reproduce it**:
easiest one is this unit test:
```
def test_scheduler_verify_infinite_pool(self):
    """
    Test that TIs are still scheduled if we only have one infinite pool.
    """
    dag = DAG(dag_id='test_scheduler_verify_infinite_pool', start_date=DEFAULT_DATE)
    BashOperator(
        task_id='test_scheduler_verify_infinite_pool_t0',
        dag=dag,
        owner='airflow',
        pool='test_scheduler_verify_infinite_pool',
        bash_command='echo hi',
    )

    dagbag = DagBag(
        dag_folder=os.path.join(settings.DAGS_FOLDER, "no_dags.py"),
        include_examples=False,
        read_dags_from_db=True,
    )
    dagbag.bag_dag(dag=dag, root_dag=dag)
    dagbag.sync_to_db()

    session = settings.Session()
    pool = Pool(pool='test_scheduler_verify_infinite_pool', slots=-1)
    session.add(pool)
    session.commit()

    dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))

    scheduler = SchedulerJob(executor=self.null_exec)
    scheduler.processor_agent = mock.MagicMock()

    dr = dag.create_dagrun(
        run_type=DagRunType.SCHEDULED,
        execution_date=DEFAULT_DATE,
        state=State.RUNNING,
    )
    scheduler._schedule_dag_run(dr, {}, session)

    task_instances_list = scheduler._executable_task_instances_to_queued(max_tis=32, session=session)

    # Let's make sure we don't end up with a `max_tis` == 0
    assert len(task_instances_list) >= 1
```

**Anything else we need to know**:

Overall I'm not sure whether it's worth fixing in those various spots:
https://github.com/bperson/airflow/blob/master/airflow/jobs/scheduler_job.py#L908
https://github.com/bperson/airflow/blob/master/airflow/jobs/scheduler_job.py#L971
https://github.com/bperson/airflow/blob/master/airflow/jobs/scheduler_job.py#L988
https://github.com/bperson/airflow/blob/master/airflow/jobs/scheduler_job.py#L1041
https://github.com/bperson/airflow/blob/master/airflow/jobs/scheduler_job.py#L1056

Or whether to restrict `-1` ( infinite ) slots in pools:
https://github.com/bperson/airflow/blob/master/airflow/models/pool.py#L49
tests/jobs/test_scheduler_job.py
dag_id = 'SchedulerJobTest.test_nonexistent_pool'
        task_id = 'dummy_wrong_pool'
        dag = DAG(dag_id=dag_id, start_date=DEFAULT_DATE, max_active_tasks=16)
        task = DummyOperator(dag=dag, task_id=task_id, pool="this_pool_doesnt_exist")
        dag = SerializedDAG.from_dict(SerializedDAG.to_dict(dag))
        self.scheduler_job = SchedulerJob(subdir=os.devnull)
        session = settings.Session()
        dag_model = DagModel(
            dag_id=dag_id,
            is_paused=False,
            max_active_tasks=dag.max_active_tasks,
            has_task_concurrency_limits=False,
        )
        session.add(dag_model)
        dr = dag.create_dagrun(
            run_type=DagRunType.SCHEDULED,
            execution_date=DEFAULT_DATE,
            state=State.RUNNING,
        )
        ti = TaskInstance(task, dr.execution_date)
        ti.state = State.SCHEDULED
        session.merge(ti)
        session.commit()
        res = self.scheduler_job._executable_task_instances_to_queued(max_tis=32, session=session)
        session.flush()
        assert 0 == len(res)
        session.rollback()
    def test_find_executable_task_instances_none(self):