Added operator[] support.

 - It is documented that find() and insert() are faster, but this exists
 mainly for convenience.

 - The performance of operator[] is basically just as fast as calling
 find/insert for queries and insertions. Update may be slower since updates
 are performed by

        // a unified update/insert will be nice. upsert is not doing
        // anything particularly different from this.
        // and this is currently biased towards inserting a new value
        // than updating an existing value
        while (!owner->insert(key, value) &&
               !owner->update(key, value));

 Note that this implementation here is not exactly STL compliant.
 To maintain performance and avoid hitting the hash table too many
 times, The reference object is *lazy*. In other words,

  - operator[] does not actually perform an insert. It returns a
    reference object pointing to the requested key.
  - On table[i] = val // reference::operator=(mapped_type)
    an insert / update is called, and the reference becomes eager.
  - On val = table[i] // operator mapped_type()
    an find / insert is called and the reference becomes eager.
  - On table[i] (i.e. no operation performed), the destructor is called
    immediately (reference::~reference()) in which case
    insert(key, mapped_type()) is called.

 Thus, with normal usage, this should behave pretty much exactly like
 a regular reference. However, where issues might occur is when the
 lifetime of the reference exceeds its usual lifespan.

 auto i = table[i]

 in which case the lifetime of reference object is extended beyond
 what we would like it to be causing issues. To avoid this issue,
 the above is banned. By making the default constructor,
 copy constructor, and assignment operator of the reference object
 private, the above will cause a compilation error.

 Though that means that annoyingly,

 table[i] = table[j]

 will cause a compilation error.

 - Having a fused find/insert and a fused insert/update will help make
 the operator[] implementation be *much* nicer avoiding the silly lazy
 reference issue.

 i.e. what will be nice to have is:

   // returns mapped value if key exists, or if key does not exist,
   // inserts (key, value) and return value.
   // equivalent to:
   // \code
   //   while(1) {
   //     mapped_type qval;
   //     if (find(key, qval)) return qval;
   //     else if (insert(key, value)) return value;
   //   }
   // \endcode
   mapped_type find_or_insert(key_type key, mapped_type value)

  and

  // Equivalent to:
  // \code
  //  while (!owner->insert(key, value) &&
  //         !owner->update(key, value));
  // \endcode
  //
  // or,
  //
  // \code
  // upsert(key, [](auto i){return i;}, value);
  // \endcode

  (though the upsert is not exactly faster than the while loop)
  mapped_type insert_or_update(key_type key, mapped_type value)

 - Changed the update functions to templatize around the Updater. This
 is generally faster since that permits lambda to be inlined rather type
 erased through the std::function.
Re-did the operator[]

Made several major changes to the original implementation of operator[]

1. No longer do we insert a default value if the user doesn't do
anything with their reference. This is more similar to how languages
like Python work, and early on we decided we like this behavior better
than the C++ behavior. Also, since our reference is going to deviate
from STL behavior significantly anyways, we shouldn't be too concerned
with emulating it.

2. This means we don't have to worry as much about extending reference
lifetimes beyond what they are supposed to be, since multiple copies
won't have an effect on the table when they are destroyed. There is
still the issue of extending the reference beyond the lifetime of the
map it points to, but deleting the default reference constructor makes
that very hard to do, and also the STL doesn't worry about that either,
so it's probably not a big deal.

3. We can also support the more natural syntax "cuckoo_map[key] =
cuckoo_map2[key2]" by overloading the operator= for a "const reference&"
parameter to simply cast the argument to a mapped_type and use the other
version of operator=.

Also changed the test and moved it from test_iterator to a new file
called test_bracket_operator, since the tests didn't really fit anywhere
else.