Make settings a lazy val.

So it's not recomputed on every access.
Support both flat and recursive classpath.
Add AbstractFile-backed FlatClasspath implementation.

It's not being used yet because we have to hook into PathResolver
and construct those objects for each classpath element.

Also, this is just to get us started with the whole idea of replacing
classpath implementation. I expect we'll get specialized versions
for JarFlatClasspath and DirectoryFlatClasspath that are optimized
for the fact that we are dealing with a jar file or a directory.
Extract classpath factory methods into separate trait.

Extracted methods responsible for classpath element creation into
separate trait that can be implemented to create either recursive
(old classpath) or flat (new classpath) elements.
Move ClasspathEntry outside of FlatClasspath.

We don't need path-dependent entries. Actually, we want to aggregate
entries from several classpath elements.
Fix return type in VirtualFile.lookNameUnchecked.

By overriding a method and setting its type to Nothing we make it
impossible to override.
Implement lookup methods in ZipArchive.

Implement various lookup methods in ZipArchive. Most of the logic
was already there so I just had to put things together.

One noticeable change is that directory entry is put under
s"{dirName}/" name instead of just dirName. That's required by
lookup methods and it was probably an omission.
Turn classpath element implementation into case classes.

So they get good-looking toString representation.
Fix numerous bugs in AbstractFileFlatClasspath

Bugs are:

  * filter out directories which are not valid package names
  * filter out files which are not valid class files
  * entries shouldn't be inner classes of AbstractFileFlatClasspath
    class because that messes up their equality (due to path-dependence)
  * not every classpath element contains given package hence
    getDirectory returns an Option[AbstractFile]
Implement AggregateFlatClasspath.

Implement AggragetFlatClasspath which aggregates a sequence
of other FlatClasspaths.

It's vastly inefficient but that's ok for now.
Switch to AggregateFlatClasspath for flat classpath implementation.

Before, we used WrappingFlatClasspath which would simply wrap an old
implementation of a classpath and expose it through FlatClasspath
interface.

In order to do that, we had to implement an alternative
PathResolver which resolves classpath elements to FlatClasspath
implementations.
Expose root entry in FileZipArchive.

Also, we traverse underlaying zip file only once and keep the
index (entries) in memory.
Depend on pack in junit tests.

This way we can have jars (instead of class dirs) on a classpath
for SymbolTable tests.
Disable debugging in symbol table test.
Remove ZipFileIndexClasspath optimisation.

This way we can compare the old and the new classpath implementation
without distorting the results by relying on caching in Java's
ZipFileIndex.
Strip class file extenstion manually.

It turned out that going through Path is expensive because
it creates a new java.io.File and makes filesystem calls.
Move implementation of PackageEntryImpl.

Moved that implementation so it's not needed in any object.
Add ZipFileIndexFlatClasspath implementation.

Add FlatClasspath implementation that delegates (a little bit poorly)
to javac's ZipFileIndex. That implementation of zip file index is
really fast due two reasons:

  * inherently it's written for performance, it populates the index
    in single, focused pass
  * it caches the index per jar file, so the next time we ask for
    the same jar we don't need to rescan it
Switch to ZipFileIndexFlatClasspath for jar files.
Loop 200 times in basicSubTypeCheck test.

It's a very poor method of measuring performance but it gives
some rough idea.