Reorganizing speculation.  Importantly, we want to allow speculation
any time that we attempt to acquire a read or write lock on a
variable.  Previously, we only permitted speculation when we called
get_val, set_val.  This does not work because container objects don't
use get_val/set_val.  Eg., to get the size of a container or a value
in an index of the container, we use get_val_on_key/set_val_on_key,
which bypass get_val/set_val and instead use
acquire_read_lock/acquire_write_lock.  This re-organization pushes
read speculation into acquire_read_lock.  Next will do the same for
write speculation, pushing it into acquire_write_lock.
See previous commit, except with write lock holders.
If the call is just a specualte call (not specualte container
internals), then we speculate on just the wrapper of an object.  For
instance, for the following code

   List(element: Number) some_list;
   List(element: Number) some_other_list;
       ...
   some_list = some_other_list;
   speculate(some_list);

Allows other events to now read/write on top of some_other_list when
accessing some_list.

However,

   List(element: Number) some_list;
   some_list.append(1);
   speculate(some_list);

does not allow other events to perform basic operations.  Eg.,

   some_list.size();

This is because speculate allows us to speculate on the pointer
wrapping the internal list, we cannot speculate on the contents of
that internal list.

To speculate on the internal value added a new method:

   speculate_container_internals(some_list);

This method should get the internal container pointed at and
call speculate on it, instead of the external wrapper.