Fix event-task leak with a counter + drain promise (WaitGroup) — alt to #15

[henrikbjorn]

Alternative to #15 (opened so both approaches can be compared side by side). Same bug, same regression test, different drain mechanism.

The bug (same as #15)

Listener::Base dispatched every ESL event through one per-connection Async::Barrier. Barrier#async retains each task until #wait, and @event_barrier.wait is only called in connection_closed (socket drop). So on a long-lived inbound connection every event permanently leaks a task node — ~GBs over days on a busy switch (the answering_machine ~8GB/2d).

This approach: counter + drain Promise (WaitGroup)

Keep only a count of in-flight event tasks plus a one-shot drain Async::Promise:

@event_tasks = 0
@drained = Async::Promise.new
@closing = false

# per event:
@event_tasks += 1
Async do
  on_event(response); invoke_event_hooks(response)
ensure
  @event_tasks -= 1
  @drained.resolve(true) if @closing && @event_tasks.zero?
end

# connection_closed (after rejecting pending promises):
@closing = true
@drained.resolve(true) if @event_tasks.zero?
@drained.wait

Retention is one integer for the whole life of the connection — nothing per-event is stored.

vs the Set approach (#15)

Both fix the leak and pass the same regression test. This one:

• stores a count, not a collection — even leaner;
• has no snapshot/iterate on drain (no .dup);
• can't truncate the drain on a hook error (the Set's each(&:wait) re-raises the first failure; Barrier#wait had the same gap).

Promise (not Condition) is deliberate: a resolve that races ahead of the wait is still delivered, so shutdown ordering can't lose the signal.

This mirrors the design already on the spike/em-style-simplification branch (33f6fbd); this PR just lands it minimally on master. Full suite green (121 runs, 0 failures).

[henrikbjorn]

Closing in favour of #15 (self-reaping Set). Both fix the leak identically and pass the same test; #15 keeps less coordinated state (one collection that self-reaps, vs this PR's counter + drain-promise + closing-flag). Keeping the simpler one. #15 now uses @event_tasks.each { it.wait rescue nil } for the drain (no snapshot needed — only deletes happen during shutdown, which MRI tolerates).