finishes the tokenstream-based parser

New functionality:
* Support for whitespace tokens
* Support for comment tokens
* Precise support for string interpolations
* Range positions for tokens

Tested the tokenizer on the entire source tree of scala/scala, and everything was fine except for:
* XML literals (not supported by the current parser, probably will be dropped from future versions of Scala)
* Unicode escapes (no idea how those should interact with positions, will ask Martin)

Also benchmarked parsing of library/reflect/compiler of Scala 2.11.2:

```
var files = List[java.io.File]()
def loop(dir: java.io.File): Unit = {
  dir.listFiles.filter(_.isFile).filter(_.getName.endsWith(".scala")).map(file => files = file +: files)
  dir.listFiles.filter(_.isDirectory).map(loop)
}
loop(new java.io.File("/Users/xeno_by/Projects/Scala2112/src/library"))
loop(new java.io.File("/Users/xeno_by/Projects/Scala2112/src/reflect"))
loop(new java.io.File("/Users/xeno_by/Projects/Scala2112/src/compiler"))


val contents = files.map(file => (file, scala.io.Source.fromFile(file).mkString)).toMap
val compilerCommand = new scala.tools.nsc.CompilerCommand(Nil, _ => ???)
val reporter = new scala.tools.nsc.reporters.StoreReporter
val global = new scala.tools.nsc.Global(compilerCommand.settings, reporter)
val run = new global.Run
def parseReflect(file: java.io.File, contents: String): Unit = {
  global.newUnitParser(contents, "<adhoc>").parse
  if (reporter.infos.nonEmpty) println(file.getAbsolutePath)
  reporter.reset()
}
val startReflect = System.currentTimeMillis()
contents.foreach{ case (f, content) => parseReflect(f, content) }
val endReflect = System.currentTimeMillis()
println("Reflect parsing: " + (endReflect - startReflect) / 1000.0)


def parseMeta(file: java.io.File, contents: String): Unit = {
  import scala.meta._
  import scala.meta.syntactic.parsers._
  try contents.parse[Source]
  catch { case ex: Exception => println(file.getAbsolutePath); throw ex }
}
val startMeta = System.currentTimeMillis()
contents.foreach{ case (f, content) => parseMeta(f, content) }
val endMeta = System.currentTimeMillis()
println("Meta parsing: " + (endMeta - startMeta) / 1000.0)
```

Results are very encouraging, since I paid almost no attention to performance:
```
23:17 ~/Projects/core/sandbox (topic/tokens)$ adhoc-metac benchmark
Reflect parsing: 3.409
Meta parsing: 6.947
```