How to avoid unnecessary consumption of points when using RateLimiterUnion?
I was intending on using `RateLimiterUnion` to rate limit requests my backend is making to a third-party API. The third-party API imposes the following rate limits:
- Max of 10 requests per second
- Max of 100 requests per minute

I am operating in a distributed environment (lambda), with multiple lambda instances reaching out to the same API concurrently, I thought I'd be able to leverage `RateLimiterUnion` along with `RateLimiterDynamo` like so to ensure I remain beneath the rate limits:

```ts
const perSecondLimiter = new RateLimiterDynamo({
  duration: 1,
  points: 10,
  keyPrefix: "per-second",
  storeClient: new DynamoDB(),
  tableName: "rate-limiter-table",
  tableCreated: true,
});
const perMinuteLimiter = new RateLimiterDynamo({
  duration: 60,
  points: 100,
  keyPrefix: "per-minute",
  storeClient: new DynamoDB(),
  tableName: "rate-limiter-table",
  tableCreated: true,
});
const limiter = new RateLimiterUnion(perSecondLimiter, perMinuteLimiter);

limiter
  .consume("foo-api")
  .then((res) => {
    // perform third-party API request
  })
  .catch((rej) => {
    // either perSecondLimiter failed or perMinuteLimiter failed
  });
```

But after looking at the `RateLimiterUnion` implementation, my understanding is that points are consumed needlessly if one of the rate limiters provided to `RateLimiterUnion` throws an error, while the other does not.

For instance, given the limiters defined in the example above, take the following example:
1. 10 points are consumed in 500ms. No rate limiting errors occur.
2. 100ms later, an attempt to consume 90 more points occurs.
    - `perSecondLimiter` detects that consuming these points would exceed the 10 points per second limit and as a result reports that the operation would exceed the specified rate limit.
    - `perMinuteLimiter` does not report an error, since fewer than 100 points have been consumed in the last 60 seconds. This results in `perMinuteLimiter` consuming points, but it doesn't make sense to consume points in this scenario, since `perSecondLimiter` indicated that making a request would exhaust rate limiting quotas (hence the actual requests were not made).
3. The limiter continues to report rate limiting errors for the next 59 seconds and 400ms. But it shouldn't, since in step 2, we couldn't actually consume those 90 points/make a request to our API because `perSecondLimiter` failed.

This seems like a pretty typical use-case for `RateLimiterUnion`, could you please advise if there is any way to get around the issue I'm facing? Many thanks.