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

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 because we cannot know that in a race free
manner without taking the lock. Replace the global RWLock with a
per-object bit lock.

Now 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. This prevents dead
locks.

Downsides:

- this requires to grow the GObject size (on x86_64) to add a
  GObjectPrivate for "optional2_flags". We cannot use the bitlock
  on "optional_flags", 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 locks for that. Add another
  gint field in GObjectPrivate for the bitlock OPTIONAL2_BIT_LOCK_G_WEAK_REF.

- now `g_weak_ref_set()` also temporarily raises the ref count on the
  old object. That is because we must keep the old object alive to take
  a OPTIONAL2_BIT_LOCK_G_WEAK_REF lock. Taking and dropping references
  emit toggle notifications, which is a visible change in behavior.