Optimization in TailCalls

Only store the position and reason for a failure to tailcall
transform a method if we ever need to report it, ie, if the
method was annotated with @tailrec.

Saves object hashing and map updates, profiling suggests
that this reduces the tailcalls phase from about 2% of compilation
time to about.

Also, clear the maps eagerly after each compilation unit,
rather than letting them accumulate entries for the entire
run. Working with smaller maps can't hurt.
Optimization in Pickler

Avoid creating an intermediate array.

The pickling phase takes about 2% of compilation; writeArray was
reporting 30% of this, and the call to take about 25% of that.

A microoptimization at best. But, life is a game of inches.
Optimize makePatDef

Avoid the varargs List(...) constructor.

Another micro-optimization that elimates a 0.2% overhead
from a compilation run.

We really ought to rewrite List(a, b, c) to `a :: b :: c :: Nil` for
smalling argument lists.

But for now, ance again, chanelling my inner Pacino:

> Now I can’t make you do it. You’ve got to look at the guy next to
> you, look into his eyes. Now I think you’re gonna see a guy who
> will go that inch with you. You’re gonna see a guy who will
> sacrifice himself for this team, because he knows when it comes
> down to it, you’re gonna do the same for him.