Rust doesn't necessarily need this, but it's good formatting to include
it anyway.

With the file name heuristic for -before and -after in place, we might
want a way for the user to disable it. For now, we simply do this by
providing a new set of predicates without the filter.

In the future, we might have a --disable-heuristics switch to disable
the heuristics, in case we ever add more.

This allows the date-based filters to work much faster.

This allows us to attach some additional metadata that is not found in
the PartialEvtc otherwise, such as the file name.

As it turns out, the "local timestamp" as advertised by arcdps is a bit
misleading, because the timestamp is still in UTC. The "local" refers to
the fact that it can lag behind the server timestamp a bit (but usually
they seem to be within +-1 of each other), not that the timestamp is in
the local timezone.

This makes date handling a bit harder for raidgrep, but thanks to
chrono, not by much. The idea is that we simply deal with Utc pretty
much everywhere, except at the user boundary. This means that

1. Input timestamps for -before and -after are converted to Utc right
   after input
2. When outputting, we convert to a local timestamp first

This makes the output consistent with the filenames now (and the "wall
time" that the player saw).

If the boss is unknown, we exclude the log - that is how
BossFilter::filter operates, and it is probably what the user wants if
they specify a -boss filter. However, in filter_early, the default for
unknown bosses was to return Inclusion::Include, which is not consistent
with filter. That lead to some logs being included, parsed and then
thrown away again.

This change makes the behaviour for unknown bosses between filter_early
and filter consistent, and therefore speeds up the search if -boss is
used.

Having a ::new on each of the filter types was a bit weird, especially
because we returned Box<dyn ...> instead of Self (and clippy rightfully
complained). With this patch, we now have a bunch of normal functions,
and we don't show to the outside how a filter is actually implemented
(or what struct is behind it).