Add per key actor epochs

See riak_kv#679 and the associated platform_task RFC and summary.

Requires https://github.com/basho/riak_core/pull/646

This PR addresses the "doomstone", backup-restore, and some byzantine flavours of the kv679 bug.

The RFC explains the mechanism in detail but briefly:

1. add a persisted to disk vnode counter (persisted with leases, aysnc)
2. when ever a key is written to for the "first time" by a vnode, create an epoch actor for the key by concatenating vnodeid+counter (and increment the counter)

This ensures that a first time write for a key gets a new actor, this is the epoch for the key. It means we don't mix up deleted+re-created keys {a,1} event with the original {a, 1} event for some key, by ensuring an actor per epoch, without causing a keyspace wide actor explosion.

I hope that is enough details for the review to start. I'll start work on EQC for the status_mgr and the new vnode functions in the mean time.

Like I mentioned on old commits, this feels like a fold since you aren't bailing early from the processing.  How about this refactor:

```erlang
{Actor, Epoch} = lists:foldl(find_highest_actor(ActorBase), {undefined, 0}, Actors),
% ...

find_highest_actor(ActorBase) -> 
    fun(ActorID, Acc) -> 
        find_highest_actor(ActorBase, ActorID, Acc)
    end.

find_highest_actor(ActorBase, <<ActorBase:8/binary, EpochCntr:32/integer>>=A, {_HighestActor, MaxEpoch}) when
      EpochCntr > MaxEpoch ->
    {A, EpochCntr};
find_highest_actor(ActorBase, <<ActorBase:8/binary, EpochCntr:32/integer>>, {_HighestActor, MaxEpoch}=Acc) when
      EpochCntr =< MaxEpoch -> 
    %% TODO: (sdc) This clause may not even be necessary! When the
    %% EpochCntr isn't greater, we just pass along the existing
    %% highest actor.
    Acc;
%% Since an actor without an epoch is lower than an actor with one,
%% this means in the unmatched case, the ActorBase passes through as
%% the highest actor, and the epoch (of zero) passes through too.
find_highest_actor(_ActorBase, _, Acc) ->
    Acc.
```

Or even simpler:

```erlang
find_highest_actor(ActorBase) -> 
    fun(<<MatchingBase:8/binary, EpochCntr:32/integer>>=A, {_HighestActor, MaxEpoch}) 
        when MatchingBase == ActorBase andalso 
             EpochCntr > MaxEpoch -> 
               {A, EpochCntr};
        (_, Acc) ->
               %% Since an actor without an epoch is lower than an
               %% actor with one, this means in the unmatched case,
               %% the ActorBase passes through as the highest actor,
               %% and the epoch (of zero) passes through too.
               %%
               %% NB (sdc): this also covers where the ActorBase
               %% doesn't match, i.e. it is some other actor entirely.
               Acc
    end.
```

I guess the reason I like to try to identify things that look like folds an reimplement them as such is it forces me to find ways to make things more succinct. In this instance, I found some of those clauses aren't even needed -- two are handled by the implementation of `lists:foldl/3`, and one is a subset of a catch-all case.