Replaces it with an anonymous struct type in the regular synchronized
blocks.  This seems desirable to me since it prevents creating an extra
class that is exposed but really shouldn't be.

The _Table_Locker object is replaced with an anonymous struct type
created in the foor loop.  It's definitely uglier but it removes the
need to expose an additional class, something I never wanted to do in
the first place.

The previous anonymous struct has a const reference to a temporary.  I
realized this was unsafe (though it did, unfortunately work).  Using
std::piecewise_construct and a pair, the _Table_Locker class can be
eliminated safely.  It's not very pretty but I can finally eliminate
that class entirely.

Coincidentally std::ref worked because something else was including
<functional>.

Using c++11 inheriting constructors the pair can be eliminated and the
TableLocker alternative is defined inline.  Inherits the lock_guard
constructor and has a bool finished with a default of false.  afaik this
behavior is all defined, there is no pair, just an anonymous class
(finally).

Instead of lg, it's now lgwithREALLYlongname to avoid collisions.  If I
was writing for the standard I'd just prefix with an underscore, but I'm
not implementing stdlib facilities so this seems for the best.