A proc macro and a macro attribute to quickly time functions. Uses `std::time::Instant` so relies on std to work. 

### \#\[time_this\]

This macro can be used to time any function you want using `std::time::Instant`. Whenever the function
gets called, its timing information will be passed to stdout (though in the case of recursive calls,
it will only be printed once). It may not work correctly with `async fn`, in particular when a future
is returned but not yet awaited, and it definitely doesn't work with `const fn`, even if called in a
non-const context. If needed, you can write a small wrapping function if you need to time a `const fn`.
It will print:
* the time in ns if the function took less than 1μs.
* the time in μs if the function took less than 1ms.
* the time in ms if the function took longer than 1ms, but less than 1s.
* the time in s if the function took more than a second, with two decimal digits.

```rust
use time_this::time_this;

#[time_this]
fn add(a: u32, b: u32) -> u32 {
    a + b
}

fn main() {
    let result = add(3, 5);
    // function 'add()' took 37ns
}
```

### time!()

This macro can be used to time any expression you want using `std::time::Instant`. After the expression
evaluates, timing information will immediately be passed to stdout and the result will be returned,
similar to similar to `dbg!()`. Similar to `time_this`, it may not work correctly with `async fn`.
Instead of printing the function name, it will print file/line the expression that was timed at, as well
as the expression itself.

```rust
use time_this::time;

fn add(a: u32, b: u32) -> u32 {
    a + b
}

fn main() {
    let result = time!(add(3, 5));
    // [tests/tests.rs:33] -> add(3, 5) took 28ns
}
```