Fixes some more of those ResourceWarnings

Many more remain.

Since now we need to pass an extra argument to loads() and Unpickler(),
but only on Python 3, the old way of ``from ZODB._compat import pickle``
no longer pays out, and I had to import the names directly.

The only remaining test failures are due to changed pickle sizes.  I've
discovered two reasons for that so far:

  1) Python 3 pickles 'native strings' as BINUNICODE, Python 2 pickles
     'native strings' as SHORT_BINSTRING, which is 3 bytes shorter.

  2) Python 3 and also the 'pickle' module Python 2 pickles tuples like
     (UserDefinedClass, ) with an extra BINPUT opcode at the end,
     compared to 'cPickle' in Python 2 when given the same tuple:

        Python 2.7.3 (default, Sep 26 2012, 21:51:14)
        [GCC 4.7.2] on linux2
        Type "help", "copyright", "credits" or "license" for more information.
        >>> import pickle, cPickle
        >>> class MyClass(object): pass
        ...
        >>> len(pickle.dumps((MyClass, None), 1))
        26
        >>> len(cPickle.dumps((MyClass, None), 1))
        24

The plan is to switch to zodbpickle instead of the builtin Python 3
pickle, then use encoding=bytes from http://bugs.python.org/issue6784
and fix the class-in-tuple encoding to match Python 2's cPickle.

This test wants to rely on OIDs that are assigned to various objects.
OIDs are assigned by Pickler.persistent_id(), which gets called during
graph traversal in a nonspecific order (courtesy randomized hashes in
Python 3), so if we want to be sure to have the right OIDs assigned to
the right objects, we need to call connection.add() manually or commit
after adding every object.

This fixes nondeterministic failures in
doctest_lp485456_setattr_in_setstate_doesnt_cause_multiple_stores

Because our test suite triggers that 'RuntimeError: dictionary changed
size during iteration' error sporadically.

Stdlib's _compat_pickle is a big help here, but I've an uneasy feeling
it's not supposed to be a public API.

Problem: in Python 2 object lives in sys.modules['__builtin__'].  In
Python 3 it lives in sys.modules['builtins'].  When we pickle object in
Python 2 and try to load it in Python 3, we end up getting a Broken
object placeholder because sys.modules['__builtin__'] is AWOL.

I'm not sure how persistentclass.txt manages to reproduce that purely in
Python 3, but that's what the new assertion failure I added reports.

Oh, I know: old pickle protocol!

    Python 3.3.0 (default, Sep 29 2012, 17:14:58)
    [GCC 4.7.2] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import pickle
    >>> pickle.dumps(object)
    b'\x80\x03cbuiltins\nobject\nq\x00.'
    >>> pickle.dumps(object, 1)
    b'c__builtin__\nobject\nq\x00.'
    >>> pickle.loads(_)
    <class 'object'>

We need to find the mapping layer that handles __builtin__ in Python
3.3's pickle and make sure our own ZODB.broken.find_global can do the
same.

In Python 2 str(SomeClass) returns "modulename.ClassName".

In Python 3 str(SomeClass) returns "<class 'modulename.ClassName'>".

We want the former.

Python 3 really wants rich comparison operators

In Python 3 object.__hash__ raises TypeError, so we need an explicit
override if we want hashability.

It seems that OIDs are assigned in random order (dictionary iteration
order perhaps), and the test made assumptions.  Add an extra
transaction.commit() between object addition to fix OID assignment
order.

(To distinguish them from real functions that actually do something when
called.)