Some more cleanups & fixes - #557

…ightBag

IntMap.size is O(n), so the code in merges comparing the number of
parents (n) with the number of entries in the merge's HeightBag could be
slow on wide merges, with a worst case O(n^2) if every parent changed
height. Solved it structurally by changing how HeightBag works. The
latter now stores the number of invalidated merge parents and the
earlier comparison is no longer needed.

Even non mergeInt merges are now a little bit more efficient I believe.

wrap just had a single use left

After a merge was unsubscribed from, it would still subscribe to a new
parent arriving via the incremental update change event. This could
cause a useless pair of subscribe and unsubscribes (unsubscribing when
the GC collected the new subscription).

Also removed the retained subscribe function in merge which was not
needed, saving a few bytes.

`runFrame` collects the switches to reconnect before it updates merges,
and reconnects them after. If a finalizer unsubscribes a switch in
between, the switch would still subscribe to its new parent, and stay
subscribed until the GC collected it. The old parent would also get
unsubscribed twice.

To fix, the switch's current parent ref now has an unsubscribed state, and runFrame
skips switches in that state.

It was only used to finalize the weak invalidator when a switch is
unsubscribed, so that a later hold change can't put the switch back into
toReconnect. runFrame skips unsubscribed switches now, so we don't need
that. Finalizing it again in the reconnect loop did nothing, since
invalidate already finalizes it.

Saves an IORef per switch subscription.

Focused.fans was defined but missing from the list of cases, so no
benchmark measured firing through fan and fanInt. Also drop the trailing
spaces from two of its names.

Fan now works like cacheEvent, where only the subscribers have a strong
reference to the fan state and no finalizer is needed to allow the
fan's parent and further up to be garbage collected.

Also fixes a race condition between the finalizer thread and the
frame-running thread, by making sure that the whole per-key subscriber
map is manipulated atomically.

It's a little bit more efficient.

Root events contained races between the finalizer thread and the frame
thread on the rootSubscribed map. A subscriber added during a teardown
would never fire, and map updates could get lost.

Map updates are now atomic and a teardown deletes only its own entry. An
MVar per setup makes the setups and teardowns of a key alternate.

Root events are now structured similarly to fans as well, making the
code more uniform.

The newSubscriberHold, propagateSubscriberHold and
getHoldEventSubscription functions were only used in initHold.

Occurrences queued before the event was torn down and set up again did
not reach its new subscribers. This includes occurrences queued after
the last subscriber was garbage collected and before the finalizer
thread or the next subscription ran the teardown.

fourmolu formats the code between CPP directives as separate top-level
parts, so a conditional inside a declaration either fails to parse.

subrepo:
  subdir:   "style.hs"
  merged:   "417c71ee"
upstream:
  origin:   "git@github.com:obsidiansystems/style.hs.git"
  branch:   "main"
  commit:   "417c71ee"
git-subrepo:
  version:  "0.4.9"
  origin:   "???"
  commit:   "???"