Leverage CAS

# Problem
The IDC cache entry lifecycle looks like:

1. MC `get id` -> *miss*
1. AR find -> *record*
1. MC `set id, record`
1. *time passes*
1. update record (e.g. AR save or delete)
1. MC `delete id`

ActiveRecord updates therefore result in a memcache state for an entry that is indistinguishable from its initial state. As multiple application servers can share a memcache server, a race condition can occur where:

1. server *A* experiences an IDC miss and issues a SQL query for a record
1. server *B* queries and updates the same record, issuing a memcache `delete`
1. server *A* issues a memcache `set` with a now-stale record

# Solution
memcache provides a CAS (compare-and-swap) option to the `set` command. When this option is used, the cas value provided is compared against the cas value for the entry, and the `set` is only applied if the cas values match.

memcache also provides an `add` command, as an alternative to `set`, which will only write the entry if it does not already exist.

The IDC cache entry lifecycle is updated as follows:

1. MC `gets id` -> *miss*
1. AR find -> *record*
1. MC `add id, record`
1. *time passes*
1. update record (e.g. AR save or delete)
1. MC `set id, :idc_deleted`

This introduces a third state, *deleted*, to the two existing states, *present* and *absent* (*miss* above). If this state is seen by IDC, the lifecycle looks like:

1. MC `gets id` -> *deleted*, *cas-val*
1. AR find -> *record*
1. MC `set cas id, record, cas-val`
1. ...

Any update of the memcache entry between the `gets` and the `set cas ...`, e.g. a `set :idc_deleted` or another `set cas ...` for the same entry, will cause the `set cas ...` to fail (the entry will not be updated).

The sequence shown in the race condition above now looks like:

1. server *A* experiences an IDC miss and issues a SQL query for a record
1. server *B* queries and updates the same record, issuing a memcache `set :idc_deleted`
1. server *A* issues a memcache `add` with a now-stale record, and the `add` is rejected

Alternatively:

1. server *A* sees `:idc_deleted` and issues a SQL query for a record
1. server *B* queries and updates the same record, issuing a memcache `set :idc_deleted`
1. server *A* issues a memcache `set cas` with a now-stale record, and the `set` is rejected

# Tasks
- [x] Merge https://github.com/Shopify/memcached_store/pull/16
- [x] Publish a new memcached_store gem
- [x] Remove memcached_store from Gemfile
- [x] Document PR
- [x] Add tests for specific cases CAS is supposed to fix

@camilo @arthurnn for initial feedback