Rename EmptyTypTree into SyntacticEmptyTypeTree

1. Change the name as Eugene believes previous name was misleading

2. Remove EmptyTree case as it's not needed any longer
Represent tq"" as SyntacticEmptyTypeTree rather than TypeTree()

Such representation codifies the fact that type tree that doesn't have
embedded syntactic equivalent must have been inferred or otherwise
provided by the compiler rather than specified by the end user.

Additionally it also ensures that we can still match trees without
explicit types (e.g. vals without type) after typechecking. Otherwise
the same quote couldn't be used in situations like:

    val q"val x = 42" = typecheck(q"val x = 42")
Better comment for SyntacticEmptyTypeTree
Merge pull request #3477 from densh/topic/syntactic-empty-type-tree

Rename EmptyTypTree into SyntacticEmptyTypeTree
WIP SI-7459 Handle pattern binders used as prefixes in TypeTrees.

Match translation was incorrect for:

  case t => new t.C
  case D(t) => new d.C

We would end up with Types in TypeTrees referring to the wrong symbols, e.g:

  // t7459a.scala
  ((x0$1: this.LM) => {
    case <synthetic> val x1: this.LM = x0$1;
    case4(){
     matchEnd3(new tttt.Node[Any]())
    };
    matchEnd3(x: Any){
      x
  }

Or:
   // t7459b.scala
    ((x0$1: CC) => {
      case <synthetic> val x1: CC = x0$1;
      case4(){
        if (x1.ne(null))
          matchEnd3(new tttt.Node[Any]())
        else
          case5()
      };

TODO: in the following, we end up with unsubstituted references to `x` in the body of the case.

object Test extends App {
  class C { class D }

  case class FooSeq(x: Int, y: String, z: C*)

  FooSeq(1, "a", ???) match {
    // case FooSeq(1, "a") => println("nope")
    case FooSeq(1, "a", x@_* ) =>
      //println(x.toList)
      null.asInstanceOf[x.type]
  }