Add RateLimiter to List iter functions.

[nathanhack]

Is your feature request related to a problem? Please describe.
Currently when using a List function it provides no way to mitigate rate limit errors.

Describe the solution you'd like
Ideally a way to rate limit requests. It could be achieved by passing in a ratelimiter interface to the function either as a new function parameter, in params, or as an option.

type RateLimiter interface{
     Take()
}

Given the current interface I would claim creating a new ratelimiter option is the cleanest/easiest way.

Describe alternatives you've considered
Currently the only way to incorporate a rate limiter is before the initial List function and then before the iter.Next() function is called. But in a concurrent application this is insufficient.

ratelimiter.Take()
iter := c.ListAggs(context.TODO(), params, opts...)
for iter.Next() {
	log.Print(iter.Item()) // do something with the current value
        ratelimiter.Take()
}

[aimscreenname]

I get connection reset by peer errors when sending too many concurrent requests on a paid plan.

Since I don't know how long each request will take to complete, I'd need an interface for releasing, too:

type RequestThrottler interface {
    Take(context.Context) (release func(), error)
}

// Example implementations
func (c *concurrencyThrottler) Take(ctx context.Context) (func(), error) {
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    case c.chan <- struct{}{}:
        return func() { <-c.chan }, nil
    }
}
func (r *rateLimiter) Take(ctx context.Context) (func(), error) {
    // https://pkg.go.dev/golang.org/x/time/rate#Limiter.Wait
    return func() {}, r.limiter.Wait(ctx)
}

// Added to https://github.com/massive-com/client-go/blob/6757495c1e198a375c786286d22eb49d407b46e5/rest/client/client.go#L78
if options.requestThrottler != nil {
    release, err := options.releaseThrottler.Take(ctx)
    if err != nil {
        return err
    }
    defer release()
}

Without Resty, I could wrap my own http.Client.Transport, but Resty starts its own timeouts before calling http.Client.Do.

[bersoare]

submitted #577, should address this use case