Implements a basic throttle meant to bound the number of jobs that can concurrently run. Additionally the `~burst_size` and `~sustained_rate_per_sec` arguments can be used to control how many jobs can be spawned in a burst, and how quickly jobs can be spawned over time. If these options are not given to `create_exn` they are unbounded.

`concurrent_jobs_target` is the desired maximum number of concurrent jobs. If the value is never changed, then this is in fact a hard upper bound. The value is mutable, however, and so may be violated temporarily if the value is reduced.

`type t`````
`include sig ... end`
`val sexp_of_t : t ‑> Base.Sexp.t`
`val create_exn : concurrent_jobs_target:int ‑> continue_on_error:bool ‑> ?⁠burst_size:int ‑> ?⁠sustained_rate_per_sec:float ‑> unit ‑> t`
`val concurrent_jobs_target : t ‑> int`
`val num_jobs_waiting_to_start : t ‑> int`
`val num_jobs_running : t ‑> int`
`val enqueue_exn : t ‑> ?⁠allow_immediate_run:bool ‑> ('a ‑> unit) ‑> 'a ‑> unit`
`val enqueue' : t ‑> ('a ‑> 'b Async_kernel.Deferred.t) ‑> 'a ‑> 'b Outcome.t Async_kernel.Deferred.t`
`type 'a u``= t```

Include `Common`, with the hack to remove the type parameter

`include Common with type a t := a u`
`type _ t`````
`val kill : _ t ‑> unit`

kills `t`, which aborts all enqueued jobs that haven't started and all jobs enqueued in the future. If `t` has already been killed, then calling `kill t` has no effect. Note that kill does not affect currently running jobs in any way.

`val is_dead : _ t ‑> bool`

`is_dead t` returns `true` if `t` was killed, either by `kill` or by an unhandled exception in a job.

`val to_limiter : _ t ‑> limiter`

Convert to a limiter