Subclassing AtomicObjects to create speculative objects, which permit future transactions to read from and write to uncommitted values.  In these cases, the events that are speculating get backed out if the event that they are speculating on gets backed out.
Started subclassing unfinished spculative objects.
Added method for starting speculation on speculative objects.  This
method creates a new speculative object created from the dirty,
uncommitted state of the original object.
Added code for keeping track of whether a speculative object is the
root speculative object (ie, not waiting on any other dirty values to
finish committing) or whether it's a derived speculative object.
Doing this so that can ensure that derived speculative objects wait to
commit until the events that they've been speculating on have.
Added state machine to speculative objects.  A derived speculative can
be in one of three states:

RUNNING --- This means that the speculative object is not the root
object and all the objects that it is speculating on have neither
completed nor aborted.

SUCCEEDED --- The speculative object is not the root object and all
the objects that it had speculated on have succeeded in committing.
The root object is now handling logic for readers and writers on dirty
value and this object should just forward commit and backout requests
to root object.

FAILED --- One of the objects we speculated on failed.  Should back
everything out.
Added backing classes for speculative lists.
Merge branch 'master' into speculative
By default, using speculative for numbers.
Had a problem with previous version of SpeculativeObjects.  Their
get_vals and set_vals held locks when they shouldn't have.  Ie,
previous code looked like:

get_val
   lock
      super_get_val
   unlock

because super_get_val blocks, would just indefinitely hold onto
object's lock.  The ugly solution I came up to for this was to change
the interface that AtomicObjects provided so that they could take in a
ReentrantLock that they would unlock after they registered the
request, etc., but before they blocked on waiting for a response.
Changing approach so that all atomics are also speculative: therefore, should not maintain separate code for speculative lists.  Should just reuse atomic list code.
Shifted all atomic variables to be speculative as well.
All atomicvaluevariables now subclass from speculative anyways.
Added in linguistic support for speculating on variables.  This is primarily to enable testing.  It's unclear if will use same syntax/ultimately expose speculation to programmers.
Separating ast nodes for call to speculate vs speculate_all.
Codegen for speculate call.
Added in bare bones structure for testing speculative execution.  Running it by itself causes everything to hang.  Must debug and figure out.
If an event starts speculating on an object, it still can get and set
values to that object in the future by accessing the same object.
Note: if it sets to that object, it should cause other events that
speculated on the object's value to roll back.
Extended speculation test to ensure that speculation actually makes a difference.  It currently hangs.
Previously, had a bug in which when the root of a speculative object
finished running we would not trigger derivative speculatives to begin
executing.  This fixes that.

Note however, we currently just pass the first phase of commit for all
speculatives that had been waiting.  Should provide a nicer way to
hook into functionality so that subclasses can override this behavior.
Updated speculation test to ensure that speculation speeds time to process.