Introduce an options argument to the `modifier()` function used to
create function-based modifiers, with a single initial option: `eager`.
Passing `{ eager: false }` opts out of the previous default beahvior of
eagerly consuming all arguments, so that function-based modifiers can
have normal auto-tracking semantics -- that is, only rerunning when the
tracked state they use changes. This allows users to opt into the new
(`eager: false`) behavior on a per-modifier basis.

There are three changes to accompany the new options object here:

1.  Add overloads to `modifier` for the following cases:

    - the user passes no options (the default up till now)
    - the user passes `{ eager: true }` (matching the previous default)
    - the user passes `{ eager: false }` (the new target behavior)

    These overloads intentionally do *not* support invoking with a
    "signature" for `{ eager: false }`. If users want to introduce an
    explicit signature for function-based modifiers, they should first
    convert to the `{ eager: false }` semantics.

2.  Update the function-based modifier manager internals to support
    this. As a result, we now need to create a new instance each time,
    with the corresponding options.

3.  Update the internals of the function-based modifier manager to use
    a state bucket, aligning it with the internals of the class-based
    modifier manager and getting rid of the need for `Map`s for keeping
    track of modifier elements and teardowns.

Since the number of options is limited, we can just create one
instance for the two scenarios we care about.