Add `Void` type

A type that is distinct from `None` that serves the purpose of being useless.
All usages of it should be reported as warnings.

I wonder if `Void` should be the root type?

So in typing land `None` actually means `Void` when it's the sole return type.

But there are other use cases:
```py
fn1: Callable[[int], None] = lambda arg: arg
fn2: Callable[[int], Optional[str]] = fn1 # Note this assignment
value: Optional[str] = fn2(123) # value would be int actually

a: Callable[[], None] = lambda: 1
b: Callable[[], None | str] = a # INVALID!
v: str | None = b()
assert v
reveal_type(v) # str, but it's actually int
```

```py
a: Callable[[], int] = ...
b: Callable[[], Void] = a # valid, the return type is covariant and Void is the root type
v: str | Void = b() # probs an error?
assert not isinstance(b, Void)
reveal_type(v) # , unreachable
```

The issue does not name any files, tests, or entry points to begin with. Clarify the semantics of Void, including its relationship to None, callable variance, unions, warnings, and root-type behavior, then define tests that establish the intended typing results.

Written by the indexing model from the issue text.