There's currently no way to get the registered directives from a
`Targets` instance, which is a barrier to some use-cases such as
combining user-supplied directives with application-supplied defaults.

This commit implements `IntoIterator` for `&Targets`. The returned
iterator will yield `(&str, LevelFilter)` pairs, on for each directive
(excluding the default level, whose `target` is `None`). Additionally,
an `iter` method has been added to `Targets` as a convenience for
obtaining an iterator for method chaining.

Items are yielded as per the underlying `DirectiveSet::iter`, which
would yield items in specifity order (as constructed by
`DirectiveSet::add`). However, the order has been left explicitly
undefined in the documentation for `Targets::targets` on the basis that
this is an implementation detail that may change.

In order to namespace the `Iter` type nicely, the
`tracing_subscriber::filter::targets` module has been made public, along
with some nominal documentation. The `filter` module continues to
re-export the `Targets` type so this is not a breaking change.

This adds an owning iterator implementation for `Targets`. The returned
`IntoIter` type is hosted in `filter::targets` alongside the existing
`Iter` type.

Due to the underlying directive storage being determined based on
features, `IntoIterator` has also been implemented on the internal
`DirectiveSet` type to keep the feature handling within that module.

This moves the logic of creating the inner iterator into a constructor
function on the iterators themselves. This brings the type definition
and implementation closer together.

The implementation has been changed to use closures, since they don't
capture and can be converted to `fn()`. This avoids repeating the
signature.

This cuts down some noise, since we use it twice.