Implement MethodDelegate for automatic type deduction from method pointers

[konard]

Summary

This PR implements a new MethodDelegate class that addresses issue #27 by providing automatic type deduction from member function pointers, enabling a more convenient syntax for creating delegates.

Key Features

✅ Automatic Type Deduction: Uses member function pointer as template parameter to automatically deduce class type, return type, and argument types

✅ Convenient Syntax: Instead of:

Delegate<void(const char *)> memberMethod(std::make_shared<Object>(), &Object::Method);

You can now write:

MethodDelegate<&Object::Method> memberMethod(std::make_shared<Object>());

✅ Backward Compatibility: Existing Delegate<ReturnType(Args...)> syntax continues to work unchanged

✅ Seamless Conversion: MethodDelegate can be implicitly converted to traditional Delegate when needed

Implementation Details

• MemberFunctionTraits: Template helper that extracts type information from member function pointers
• MethodDelegate<method>: New class template that takes a member function pointer as a non-type template parameter
• Perfect Forwarding: Supports universal references for optimal argument forwarding
• Type Safety: Compile-time type checking ensures correct usage

Example Usage

struct Object {
    void Method(const char *str) {
        std::cout << "Object::Method(" << str << ")" << std::endl;
    }
};

// New convenient syntax
auto obj = std::make_shared<Object>();
MethodDelegate<&Object::Method> delegate(obj);
delegate("Hello World");

// Can be converted to traditional delegate
Delegate<void(const char*)> traditional = delegate;

// Works with generic functions
void call(auto&& delegate) {
    delegate("calling delegate");
}
call(delegate);

Test Coverage

The implementation includes comprehensive tests covering:

• Basic functionality with different argument types
• Return value handling
• Multiple arguments
• String parameters
• Equality comparison
• Conversion to traditional delegates
• Generic function compatibility

Test plan

• All existing tests pass (backward compatibility maintained)
• New MethodDelegate tests pass
• Demo program runs successfully
• Type deduction works correctly for various method signatures
• Conversion between MethodDelegate and traditional Delegate works
• Perfect forwarding preserves argument types

🤖 Generated with Claude Code

---

Resolves #27