WIP: gobject: use per-object bit-lock instead of global RWLock for GWeakRef

WIP: tests still failing.

Replace the global RWLock with a per-object locking.

g_object_unref() needs to take a lock for GWeakRef while decrementing
the reference count to zero. That is also the case, when no weak refs
actually are registered. Replace the global RWLock with a per-object bit
lock.

There are actually two locks. The per-object lock
OPTIONAL2_BIT_LOCK_G_WEAK_REF and a bit lock WEAK_REF_LOCK on
`&weak_ref->priv.p`.

The object lock OPTIONAL2_BIT_LOCK_G_WEAK_REF must be taken first, we
cannot take it after having a WEAK_REF_LOCK lock. Otherwise there would
be deadlocks.

Unfortunately, this requires us to add another guint field
optional2_flags for locking. This increases the size of all GObject by
16 bytes (on x86-64) That's because while holding _weak_ref_lock(), we
need to be able to call g_object_ref(). g_object_ref() locks on
OPTIONAL_BIT_LOCK_TOGGLE_REFS. If OPTIONAL2_BIT_LOCK_G_WEAK_REF were on
the same "optional_flags" as OPTIONAL_BIT_LOCK_TOGGLE_REFS, it would
mean we have cases where we take

   OPTIONAL2_BIT_LOCK_G_WEAK_REF && _weak_ref_lock()

and cases where we take

  _weak_ref_lock() && OPTIONAL_BIT_LOCK_TOGGLE_REFS

That would deadlock. We need distinct logs for that, and need another
int field in GObjectPrivate for the bitlock OPTIONAL2_BIT_LOCK_G_WEAK_REF.

New and noteworthy is that `g_weak_ref_set()` now calls

  old_object = g_weak_ref_get (weak_ref);
  ...
  g_object_unref (old_object);

It wouldn't work otherwise, to get a OPTIONAL2_BIT_LOCK_G_WEAK_REF on
old_object. Because we can only access weak_ref->priv.p when having a
_weak_ref_lock(), but also, we cannot take an object lock
OPTIONAL2_BIT_LOCK_G_WEAK_REF while holding a _weak_ref_lock().