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.

 - 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.