add credit leases, reservations, and preflight checks

[bpapillon]

Brings the Java SDK to parity with Node, Go, and Python on credit leases and reservations.

check with a usage now reserves credits: in client mode against a lease held locally (in memory, or in Redis so a fleet shares one lease), in server mode with one check-and-reserve call. trackWithReservation settles the reservation and release refunds an unused one. The plain check takes usage, eventUsage, and creditCost preflight options, threaded to both the API body and the local engine. Identify can prewarm a lease. Extend and check-and-reserve each send a fresh idempotency key per call and keep the transport's default retries. A per-check timeout bounds the server-mode call, the lease acquire and extend, and a joiner's wait on a shared extend.

The Redis key layout and Lua scripts are Node's, byte for byte, so a mixed-language fleet shares leases. conformance/ is copied verbatim from schematic-node and the runner passes every vector on both backends. Java has no in-process Redis fake, so the Redis backend runs on embedded Redis; the Lua expiry guard reads the Redis server clock, so the runner moves time by shifting stored deadlines back rather than by faking the clock.

Holds, settle debits and the settle's track quantity all round a fractional usage up to whole event units, as every SDK now does. RulesEngine gains a default four-argument checkFlag that ignores its options, so existing implementations and mocks keep working. Everything new is Java 8 source compatible.

Behaviour change: a DataStreamClient that fails to start no longer throws from the constructor. The client logs it and falls back to the API, and auto lease mode resolves to server gating per check.

build.gradle is generated; the embedded-redis test dependency lives in fern-config custom-dependencies (schematic-fern-config #492, merged) so a regen keeps it.

[cbrady]

here's some claude-slop:

  1. Extend single-flight is check-then-act, so concurrent callers each send their own extend. In CreditLeaseManager.java:
  Flight inFlight = extendFlights.get(key);
  if (inFlight != null && joinsLeft > 0) { ... }
  return startExtend(...);   // startExtend: extendFlights.put(key, flight);
     - When several threads see the lease drop below its low-water mark at once, they can all get null from extendFlights.get(key). Each then calls put and sends a wire extend with its own fresh idempotency key.
     - The re-check in startExtend (stillNeedsExtending) only catches an extend that has already landed, not one still on the wire.
     - With N threads, the server grants N top-ups, and the lease holds N×leaseSize of the company's balance, which can starve other processes sharing that balance.
     - Node doesn't have this because its get-then-set runs without an await in between.
     - Fix: register with putIfAbsent when there is no flight. Keep the deliberate overwrite only for the path where a caller has used up its joins, via replace(key, old, new).
  2. Server mode doesn't round fractional usage up. ServerCreditCheck.java sends .quantity(request.getUsage()), but Node sends quantity: Math.ceil(options.usage) (added in node #194).
     - The settle does round up ((long) Math.ceil(actualQuantity)). So with usage(0.5) at a rate of 10, the hold is 5 credits but the settle bills 10.
     - Every fractional server-mode check holds less than it will bill, and client mode already rounds up, so the two modes disagree.
     - ServerCreditCheckTest.sendsAFractionalUsageAsTheQuantityToHold asserts 0.5, which locks in the old behaviour. Its comment ("the server holds the same amount every other SDK would") is now wrong.
  3. The per-check timeout restarts at every step instead of bounding the whole check.
     - In the maybeExtend loop, every join calls inFlight.await(timeout) with the full budget. After up to MAX_EXTEND_JOINS = 2 joins, the caller sends its own extend with another full timeout.
     - CreditCheck also passes the full request.getTimeout() to both acquireIfNeeded and maybeExtend.
     - A 200ms check can take about 800ms. Node computes one joinDeadline up front and waits only for whatever time is left.
     - Fix: turn the timeout into a nanoTime deadline once, at the start of the check, and pass the time remaining to each step.