Pushed some noisy logging down to debuglog.
Removed some dead code in Uncurry.
Positioned variations of inform/warning/globalError.

Because who doesn't want a little positioning in their life.
Cosmetic cleanup in the matcher.
Cleanups in Unapplies.
Add checkability condition.

All parents of an intersection type must be checkable for the
type to be checkable.
Minor improvement in pattern typer inference.

This exploits the infrastructure developed for checking the
checkability of type patterns to improve pattern type inference,
which suffered from a similar deficit. There was a hack for
SI-2486, the best I could manage at the time I wrote it; that
is replaced with the principled approach.
An Unapplied extractor.

This makes it a lot less error prone and redundant to find the
part you need when unwrapping an UnApply tree.
Pattern matcher: extractors become name-based. [All pass]

A single-value extractor is no longer required to return
Option[T], and can instead return anything which has methods
with these signatures:

  def isEmpty: Boolean
  def get: T

A multi-value extractor can return anything which has methods
with these signatures. If you're counting allocations, please
note that "get" is never called: it is there in the short term
only to signal the arity and types of the individual elements.

  def isEmpty: Boolean
  def get: ((T1, T2, ...))
  def _1: T1
  def _2: T2
  ... // up to the number of typeargs in get

This has significant benefits and opens new territory:

  - an AnyVal based Option-like class can be used which
    leverages null as None, and no allocations are necessary
  - for primitive types the benefit is squared (see below)
  - the performance difference between case classes and
    extractors should now be largely eliminated
  - this in turn allows us to recapture great swaths of
    memory which are currently squandered (e.g. every
    TypeRef has fields for pre and args, even though these
    are more than half the time NoPrefix and Nil)

Here is a primitive example:

  final class OptInt(val x: Int) extends AnyVal {
    def get: Int = x
    def isEmpty = x == Int.MinValue // or whatever is appropriate
  }
  // This boxes TWICE: Int => Integer => Some(Integer)
  def unapply(x: Int): Option[Int]
  // This boxes NONCE
  def unapply(x: Int): OptInt

As a multi-value example, after I alter TypeRef to extend
Product3[Type, Symbol, List[Type]], the extractor becomes

  def unapply(x: TypeRef) = x

Which, it need hardly be said, involves no allocations.

Future work would certainly include sequence extractors, but
the possibilities are much richer than mere sequences.
Various consolidation [all pass]
Tests for name-based pattern matcher.