Add hashing of public names defined in a source file.

A hash for given name in source file is computed by combining
hashes of all definitions with given name. When hashing a single
definition we take into account all information about it except nested
definitions. For example, if we have following definition

class Foo[T] {
  def bar(x: Int): Int = ???
}

hash sum for `Foo` will include the fact that we have a class with
a single type parameter but it won't include hash some of `bar`.

Computed hash sums are location-aware. Each definition is hashed along
with its location so we properly detect cases when definition's signature
stays the same but it's moved around in the same compilation unit.

The location is defined as sequence of selections. Each selection consists
of a name and name type. The name type is either term name or type name.
Scala specification (9.2) guarantees that each publicly visible definition
is uniquely identified by a sequence of such selectors.

Here comes the detailed list of changes made in this commit:

  * HashAPI has new parameter `includeDefinitions` that allows
    shallow hashing of Structures (where we do not compute hashes
    recursively)
  * HashAPI exposes `finalizeHash` method that allow one to capture
    current hash at any time. This is useful if you want to hash
    just a list of definitions and not just `SourceAPI`.
  * `Source` class has been extended to include `_internalOnly_nameHashes`
    field this field stores list of name-hash pairs for given source file.
  * `AnalysisCallback` extracts (see `publicDefs`) all public definitions
    from given `SourceAPI` and computes name-hash pairs
    (see `nameHashes)
  * Adds a test-case that involves cyclic structures so we make sure they
    are properly supported (we don't get StackOverflowExceptions)

Add test case for Parent-Child relationship between classes.
Methods defined in Parent shouldn't affect hash of the name of
child class.

Add NameHashes to SourceAPI.

NameHashes are added to SourceAPI because we need a container
for two collections of NameHash pairs: regular members and implicit
members. Also, include inherited definitions in computed name hashes.

Always hash definitions in structural types.