Optional Generics?

A problem with the current Generic implementation, is anytime you want to specify one type, you need to declare them all. This can lead to excessive typing and obfuscation of intent.

Sometimes I find I need to add specificity to just one of the types, it would be nice if this could be expressed as:
```
useProp<_, _, float>();
```
Instead of the current:
```
useProp();
```
I've had to do this when there is some ambiguity to the inferred types, and you need to add a little bit of an extra hint to the compiler.

An example of such a case is like this:
```
class Thing {}
void useThing(Thing t, T value) {}

void fn() {
//Thing t is declared to be of type bool
Thing t = Thing();
// But somehow, this is not an error...
useThing(Thing(), 1); // No error here :(
// We need to give it another hint;
useThing(Thing(), 1); //Now we have an error :)
}
```

If Thing was instead Thing this gets pretty annoying. The fact it falls to dynamic here is also annoying, but I guess that is a separate issue, or maybe a linter rule I'm missing.

The issue names no implementation files, tests, or entry points. Start by reviewing the proposed partial type-argument syntax and the Thing inference example, then determine the language behavior that would need to be specified. Done means reaching a decision on optional generic arguments and the related inference behavior.

Written by the indexing model from the issue text.