Update benchmark allocations helper to support min count.

This is useful when we have many groups because each group
is a separate class.
Refactor specs to not use private config API.

`config.include_extend_or_prepend_modules` is an internal
API that I plan to change in an upcoming commit.
Remove spec for behavior we will no longer be supporting.

Fully supporting metadata mutation is fraught with difficulties
see (rspec/rspec-rails#829 and the attempted fix in #1089).
For RSpec 3, we decided to expose `define_derived_metadata`
as an officially supported way to accomplish the sorts of
things metadata mutation was used for in RSpec 2. This spec
got left behind (since it was passing at the time, it wasn't
noticed) but isn’t something we want to support going forward
since module inclusion shouldn't mutate metadata. It’s also
getting in the way of a perf optimization I'm implementing.
Reify new FilterableItemRepository abstraction.
Refactor config metadata filtering to use new FilterableItemRepository.

This should perform better.
Add benchmarks demonstrating that our optimization is in fact faster.
Reduce BaseHookCollection API.

We don't need all array methods. The class definition
will load faster with fewer method defs. Also, static
method defs perform better than dynamic `define_method`
method defs since it doesn't need to activate the closure
environment.
Move hook selection into base hook collection.

Also, flatten the inheritance hierarchy a bit, which
should perform ever-so-slightly better since there are
fewer modules in the ancestor chain to check for method
defs when dispatching messages.
Combine filtering and running hooks into a single method.

Before, these things were split into separate methods (`for` and `run`),
even though they are never needed individually. The split caused us to
create extra unnecessary instances of `HookCollection` in order to
maintain the extra state between `for` and `run` without mutating the
existing instance.

The allocation benchmarks show that this reduces the number of objects
created per example group by 2 arrays and 2 HookCollection instances.
Move method def to be nearer to similar methods.
Refactor around hook execution.

- Prefer `yield` to `&block` -- it performs much better.
- Restore optimization from cd9185712375e7f81ac70531c681c1fa71a25a3e.
- This allows us to remove `empty?` from HookCollection.
Remove unneeded flattening and extra object allocations.
Reduce duplication of methods that run hooks.
Refactor: make AroundHookCollection not subclass HookCollection.

At this point it is not needed at all.
This allows us to change HookCollection to no
longer take an `initialize` argument, meaning `hooks`
is 100% internal to it now.
Split FilterableItemRepository#add into `append` and `prepend`.

This prepares it for use by hook collections, which need both methods.
Rename `items` to `items_and_filters`.

It contains both, so the name should reflect that.
Refactor hook specs to be less coupled to internal hook structure.
Switch hooks to use FilterableItemRepository.

This allows us to kill off `Hook#options_apply?`.
Lazily instantiate HookCollection instances when needed.
Remove `Example/ExampleGroup.apply?`.

We want filtering to primarily go through FilterableItemRepository
so it’s better to not even support it directly off of these classes.

Ideally, we’d refactor FilterManager to use FilterableItemRepository
but they are essentially inverted: FilterManager tracks filtering
rules, and then is asked individually about whether or not an example
(the “filterable item”) is filtered.