Add utility function for helping with overload resolution
Add utility function for helping with overload resolution

When registering functions using the Def<index_type, class, class..>()
functions from FunctionWrapper and ClassWrapper it is already possible
to select the correct overload by specifying template arguments like
FunctionWrapper::Def<name, void, int>(Foo) in case there's both Foo(int)
and Foo(double) for instance.
However that requires typing the return type which isn't strictly needed,
and doesn't work for derived classes. E.g. consider

struct X
{
  void Foo(int);
  void Foo(double);
};
struct Y : X
{
};

then

ClassWrapper<Y>::Def<name, void, int>(&Y::Foo)

will not compile and the alternative is to either write a free wrapper
function or invoke ClassWrapper<Y>::Def<name, X, void, int>(&Y::Foo),
both again more typing than really needed.

Using the resolve() function allows skipping return type and somewhat
less typing for both cases:
FunctionWrapper::Def<name>(resolve<int>(Foo));
ClassWrapper<Y>::Def<name>(resolve<int>(&Y::Foo));

stinos/micropython-wrap,stinos/micropython-wrap,stinos/micropython-wrap