Make TypeHandler far more usable

[lousyphreak]

Is your feature request related to a problem? Please describe.
The way Typehandler is designed makes it very hard to add custom TypeHandlers that cover similar classes, or more specifically enums with std::enable_if.

Describe the solution you'd like
Add a second template parameter to Typehandler:

template <class T, class Enable = void>
class TypeHandler: public AbstractTypeHandler
// implementation...

This should not break any existing code, since the parameter is new and has a default.

Describe alternatives you've considered
I do not think that there are alternatives, but i would be glad to be told that i am wrong :)

Additional context
Adding the second parameter enables creating a TypeHandler that works for all enums:

template <typename EnumT>
class TypeHandler<EnumT, std::enable_if_t<std::is_enum_v<EnumT>>>
{
public:
    static std::size_t size()
    {
        return 1;
    }

    static void prepare(std::size_t pos, const EnumT& obj, AbstractPreparator::Ptr pPreparator)
    {
        poco_assert_dbg(!pPreparator.isNull());
        pPreparator->prepare(
            pos,
            reinterpret_cast<const typename std::underlying_type<EnumT>::type&>(obj));
    }

    static void bind(std::size_t pos, const EnumT& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
    {
        poco_assert_dbg(!pBinder.isNull());
        pBinder->bind(
            pos,
            reinterpret_cast<const typename std::underlying_type<EnumT>::type&>(obj),
            dir);
    }

    static void extract(std::size_t pos, EnumT& obj, const EnumT& defVal, AbstractExtractor::Ptr pExt)
    {
        poco_assert_dbg(!pExt.isNull());
        if (!pExt->extract(
            pos,
            reinterpret_cast<typename std::underlying_type<EnumT>::type&>(obj)))
                obj = defVal;
    }
};

Adding that TypeHandler directly to poco might not be a good idea, but with the second template argument consumers of Poco can decide to do it on their own.

[matejk]

I think that similar approach could also be used with Poco::Dynamic::Any (#4363, #4341).

[aleks-f]

@matejk this is different because it's statically typed; Dynamic::Var allows for dynamic datatypes discovery and binding, but the flexibility comes with a performance price

[matejk]

@aleks-f: Sorry for not being clear.

I was more referring to having partial specialisations for a group of types (like integers, enums, floats) instead of having specialisations for each type separately in Dynamic::Var.