I recommend against using `bound=Tuple` for the following reasons:
1. If we drop support for packed (non-unpacked?) usage, it's entirely unnecessary and is just extra verbosity that provides no value.
2. I think it will confuse many users because it means that the `bound` has a different semantic meaning if the TypeVar is used in both a variadic and non-variadic context.
3. It eliminates the possibility of using `bound` for variadic TypeVars in the future. I think there are real use cases that we will want to enable here. For example, a class that accepts an arbitrary number of generic types where all of those types needs to be sized. This could be expressed as:
```python _T = TypeVar("_T", bound=Sized) class MyClass(Generic[*_T]): ... ```
4. Python developers are still getting used to typing and generics, and I've found that many of them forget to (or don't understand that they need to) supply type arguments when using a generic type within a type expression. For that reason, Pyright emits a warning (or an error in "strict" mode) if type arguments are not provided. So `Tuple` would emit a warning, whereas `Tuple[Any, ...]` would not. This warning has proven very useful to many users, and I don't want to eliminate it, but I'd probably need to eliminate it (at least in some contexts) if we advocated the use of `T = TypeVar("T", bound=Tuple)` in this PEP.