Exercise 3: A Capacity-1 Buffer Works Correctly Too — Possible Solution
====================================================================

THE TEST
------------------------------
    CAP_E3 = 1   # the smallest possible bounded buffer
    # 1 producer, 1 consumer, 10 items, real fixed (Finding 4) BoundedBuffer
    # QUANTUM=1

RESULT
------------------------------
    capacity=1 buffer, 10 items produced/consumed, QUANTUM=1:
    consumed 10 of 10 in 20 steps

Every one of the 10 items was delivered, in order (sorted(consumed_log)
== list(range(10))), using exactly 20 real steps -- 2 steps per item
(one successful produce, one successful consume), with zero wasted
retries in this particular run.

WHY A CAPACITY OF 1 IS THE TIGHTEST POSSIBLE CASE
------------------------------
With capacity=1, empty starts at 1 and full starts at 0. A producer
can only ever get ahead of the consumer by exactly one item -- the
instant it produces, empty drops to 0, so it can never produce a
second item until the consumer has taken the first one and released
empty again. The producer and consumer are forced into a strict
lockstep, alternating turns with essentially no slack at all --
exactly the scenario most likely to expose a synchronization bug,
since there's no buffer of "extra room" to paper over a mistake in
the coordination logic.

WHY THE FIX DOESN'T DEPEND ON BUFFER SIZE
------------------------------
Nothing in try_produce() or try_consume() references self.capacity
except to compute the actual array INDEX to write/read
(self.write_idx % self.capacity) -- the semaphore logic itself (which
permit to check, which to release) is completely independent of how
big the buffer is. The empty/full pair enforces "don't produce past
what's genuinely free" and "don't consume what genuinely isn't there
yet" as PURE COUNTING invariants -- they hold at capacity 1 exactly
the same way they hold at capacity 3 (Finding 4) or capacity 1000, for
the identical structural reason. If the fix had secretly depended on
having "enough slack" to hide a timing issue, a capacity-1 buffer
would be exactly where that would surface first -- and it doesn't.

WHY THIS WORKS AS AN ANSWER
------------------------------
Testing the smallest possible capacity, where producer and consumer
have the least possible room to get out of step with each other,
is the strongest available confirmation that Finding 4's own fix is
correct by CONSTRUCTION (the semaphore counting invariant itself)
rather than correct by coincidence at whatever capacity happened to
be tested first.