Mutating Methods Working

We now persist the changes made by methods which alter their reciever. The
motivating example is the `push!` method in array. It was a convient and
easy to write derived method; simply a distructive version of `push`.
Howerver it exposed a bug (or more accuratly an intentionally
unimplimneted feature) that when a method modified an object those
modification were lost at the end of the methods exicution.

To solve this problem required that we know where to put the modified
object back. Locating that place is the job of the new `evalWithContext`
function.  In addation to resulting value, it also provides a function
that will place a modified value back into the context in the correct
place.

NOTES:

In working through the changes in context, I found a number of places
where I was not careful about only touching the parts of the context that
needed to change but instead would blow away all changes to context by
replacing it with an earlier version. I suspect that I have done this
other places as well.  Also, I have not thuroughtly tested the multi
threaded nature of the new context changes.  I suspect some of them may
result in deadlocks due to insufficient care managing looping call chains.

I have yet to impliment `evalWithContext` for either Call or Indexed
nodes.  The default case is no worse then what was there before this
commit, but constructs like `a.push!(5).push!(7)` will fail to record the
second change.

Other Changes
-------------

The REPL has been changed so as to use the internals `puts` method to echo
results.  Because `puts` runs in the EvalM monad, it can produce much
better results then what can be had with the show instance of `Value`
which cannot see beyond the presented structure. For example it cannot
discover the proper name of an instance's class because it cannot send a
message to a PID.