Differentiate between runtime and typing-time annotations

[charliermarsh]

Summary

In Python, the annotations on x and y here have very different treatment:

def foo(x: int):
  y: int

The int in x: int is a runtime-required annotation, because x gets added to the function's __annotations__. You'll notice, for example, that this fails:

from typing import TYPE_CHECKING

if TYPE_CHECKING:
  from foo import Bar

def f(x: Bar):
  ...

Because Bar is required to be available at runtime, not just at typing time. Meanwhile, this succeeds:

from typing import TYPE_CHECKING

if TYPE_CHECKING:
  from foo import Bar

def f():
  x: Bar = 1

f()

(Both cases are fine if you use from __future__ import annotations.)

Historically, we've tracked those annotations that are not runtime-required via the semantic model's ANNOTATION flag. But annotations that are runtime-required have been treated as "type definitions" that aren't annotations.

This causes problems for the flake8-future-annotations rules, which try to detect whether adding from __future__ import annotations would allow you to rewrite a type annotation. We need to know whether we're in any type annotation, runtime-required or not, since adding from __future__ import annotations will convert any runtime-required annotation to a typing-only annotation.

This PR adds separate state to track these runtime-required annotations. The changes in the test fixtures are correct -- these were false negatives before.

Closes #5574.