Emitter: Properly calculate signatures of generic properties.

The old function for doing it was not only copy+pasted, but must have never
been checked because it just crashed on anything.

A new function has been added that's smaller, simpler, and uses
build_untemplated_sig to calculate the right resulting signature.

New test added to make sure this doesn't break again.
Emitter: Better, proper type inference when static things go against A.

Consider this:
    function f[A](A value1, A value2) {}
    any a = 10
    f([1], [a])

In this scenario, the 'A' of the function is unknown on the first pass. On the
second pass, it's known as list[any]. This type information is then used for
inferring the proper type of the second argument.

This now works for the value of a hash, and the many values of a tuple.
Additionally, this fixes a case that previously not only DIDN'T work, but
went and crashed the emitter (the tuple case).

Hurray type inference!
Emitter: Oops, print names for functions passed on args for argument issues.

Previously, this was printing functions passed as args as though they were
anonymous (untrue).

Add a test to make sure this silly problem doesn't come back.
Emitter: Generic parameter functions should autoresolve.

Consider this:
    function f[A, B](function g(A), B value) { f(value) }

Though g is a generic function, it is a generic function who's types are
quasi-known. That is, the A of g can be anything that also is the A of f.

Since there is no guarantee here that B is able to be A, this cannot be
allowed to proceed.

In short, local functions of a generic functions should have their generics
automatically resolved so that this can't happen.

Otherwise:
    function k(integer a => integer) { return a }
    f(k, "11")

would work, and it should not.

Credit to: https://twitter.github.io/scala_school/type-basics.html
for mentioning that this wouldn't work in Scala and thereby making me notice
the problem.