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.
Endpoints on the same host should use the same set of globals.
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.