interprets local declarations

The previous commit demonstrated updating the heap, and this commit
shows how to update lexical scope when we interpret local declarations.

Note that this code is only about locals. Since we ignore templates
(parts of classes, traits and modules) that define members, interpretation
never reaches non-local declarations.

Please note that we don't use names here - everything is based on symbols
that are always filled in in TSTs, because typer resolves all references.
This makes sure that our implementation is robust enough to handle everything
that Scala's scoping rules might throw at us (shadowing, renaming, import prioritization, etc).
interprets assignments

This commit completes the picture of Env mutators by handling assignments.

Note that after typechecking all assignments that actually stand for calls
to `update` methods get desugared into applications, so here we only have
to deal with real assignments.

Note that typechecking normalizes all references, which means that all
qualified references become qualified, even if they were written unqualified.
For example `x` in the following code would become `this.x` in TST:

  class C {
    def x = 42
    println(x) // will be typechecked as println(this.x)
  }

This little bit of knowledge allows us to distinguish assignments to
local variables and assignments to fields.
interprets references

Sketches interpretation of references (Ident, Select and This nodes).
Implementation is going to be split between name lookups in Env and
member lookups in Value.

Please note that all lookups happen using symbols, not names.
This makes sure that our implementation is as robust as possible.
interprets new

This commit handles another fundamental tree, and in this case there's
some sort of a twist.

The thing is that at a glance New seems to be completely unrelated to
its usages in Scala code (`new C`, `new C { ... }`, etc).

Handling of object instantiation is indeed quite an obscure area of scalac.

First of all, complex `new C { ... }` constructs (those that have multiple
parent classes or an explicitly specifed {...} block) are desugared into
an anonymous class definition + its instantiation.

Secondly, simple `new C(1, 2)` constructs are parsed in an unusual way:
Apply(Select(New(Ident(C)), <init>), List(1, 2). Quite a roundabout approach
to representing instantiation, right? Well, yes.

However, for our purposes this extravagant encoding of constructor invocations
actually makes a lot of sense. We can interpret New(_) in a very simple manner,
namely as creation of a raw Value, and then the constructor will be called
for us later when execution flows into the Apply part of the instantiation expression.