Using `std::function` and an opaque pointer are pretty much
antithetical. This commit chooses the more C++-y variant, i.e.
`std::function`.

Using `typedef enum` is a C-ism.

Prefer inline functions over macros, use explicit nullptr checks,
do not mark functions with implicit inline linkage as inline,
re-use code where possible, etc.

Move methods that do not need to be inline into their own file,
replace `std::function` with a template variant for performance,
remove `inline` for functions with implicit inline linkage.

Use the more C++-y `std::function` approach which renders opaque
pointers unnecessary.

- Do not create new `v8::Function` objects, both for performance
  and because it is unclear whether that leaks memory
  (Node.js issue 28988).
- Do not put functions into the inline header that do not need to
  be there or that do not make sense as inline functions
  (in particular, callbacks that are provided to C libraries can
  not be realized as inline functions by the compiler).
- Remove implicit/redundant `inline` qualifiers and add appropriate
  `const` qualifiers.
- Remove unnecessary `this->` prefixes.
- Return early for JS failures rather than accumulating them.
- Minor stylistic changes.

Use a template class instead of virtual methods to allow inlining
the subclass methods, as well as other minor cleanups.

The extensive testing done on http2 makes it easier to make sure
the implementation is correct (and doesn’t diverge unnecessarily).

This listener currently had the drawbacks of leaking memory
when an error is encountered and was otherwise equivalent to
the default listener.

Use default initializers, `const` qualifiers, minor style changes
to match more common style in the codebase.