Fix CRDTs by moving away from tracking state locally

* Testing improvements for data types
    * Establish datatype bucket types for testing in buildbot (`crdt-setup`)
    * Extend datatype testing to include round trips to server
* Move away from state-based logic to pushing all operations to Riak
    * Remove `dirty_value/1` from all data types
    * Maps now embed records representing their nested types instead
      of raw values
* Throw exceptions when "dangerous" CRDT operations are attempted and
  no observed context has been supplied:
    * Removing a value from a set
    * Erasing a field in a map
    * Disabling a flag

To continue this thought: In the way this previously worked, wrappers would only be created when a user wants to modify a nested type. If the key did not exist in the received value, you would get a brand-new wrapper of the desired type. If it did exist in the value but hadn't been updated before, you'd get a brand-new wrapper instantiated with the received value. Although this part was probably broken before, ideally if it had already been updated you would get the existing wrapper.  So, I suggest rewriting `update/3` and `find_or_new` like so:

```erlang
update(Key, Fun, #map{value=V, updates=U, context=C}=M) ->
    NewValue = case orddict:find(Key, U) of
                   {ok, Wrapper} ->
                       Fun(Wrapper);
                   error ->
                       Fun(make_wrapper(K, V, C))
               end,
    M#map{updates=orddict:store(K, NewValue, U)}.

make_wrapper(Key, Values, Context) ->
    Mod = type_module(Key),
    case orddict:find(Key, Values) of
        {ok, InitValue} ->
            Mod:new(InitValue, Context);
        error ->
            Mod:new(Context)
    end.
```