Rate-limited logging for frequent events

Often we want to tell the user about an event
that is undesirable when it happens, 
but which can happen very frequently.
In that case, we don't want to log "There was a problem!"
a thousand times per hour.  
Instead, we'd like our logs to look more like
"There was a problem! (This message repeated 1000 times in the last hour.)"

This crate adopts a multi-part solution to the problem.
At the lowest level, there is a [`Loggable`] trait,
for events which can accumulate and eventually be flushed;
this combines with the [`RateLim`] structure,
which is responsible for managing the decision
of when to flush these [`Loggable`]s.

We also provide a set of types to help implement [`Loggable`]
for simple success/failure conditions,
and a set of macros to instantiate a lazy-static `RateLim<Loggable>`
that logs a success or failure message of your choosing.
In most cases, you should call one of those.

# Example

```
use tor_log_ratelim::log_cond_ratelim;

# fn some_func() -> Result<(), ()>;

let result = some_func();
log_cond_ratelim!{
    result.is_err() => {
        // If we're seeing failures, we log this message
        // occasionally, along with a count of the failures and 
        // the amount of time we are summarizing.
        "Unable to complete some_func"
    } else {
        // After we are no longer seeing failures, we log this message
        // after a while to tell the user so.
        "No problems encountered from some_func"
    }
}
```

The above example might produce outputs more or less like these:

``` 
Unable to complete some_func (Problem occurred 7/10 times in the last minute)
Unable to complete some_func (Problem occurred 81/92 times in the last 5 minutes)
No problems encountered from some_func (Problem occurred 0/106 times in the last 5 minutes)
```
