Simplify EnsureExtensions.h implementation

[konard]

🎯 Issue

Fixes #45 - Simplifies the overly complex EnsureExtensions.h implementation

📋 Problem Analysis

The original implementation had several layers of unnecessary complexity:

• Multiple function overloads with recursive calls between them
• Lambda-based lazy evaluation for simple string messages
• std::string parameters for static messages
• Function call overhead from multiple delegations

✨ Solution

Significantly simplified the implementation while maintaining identical functionality:

Key Changes Made:

1. 🔧 Replaced std::string with std::string_view for static messages (as suggested in issue comments)
2. 🚀 Eliminated complex lambda-based message builders for simple cases
3. ⚡ Reduced function call overhead by implementing logic directly instead of recursive delegation
4. 📝 Added noexcept(false) specifications where appropriate
5. 🔄 Updated forward declaration in Range[T].h to match new signatures

Before vs After:

Before (complex lambda approach):

template <typename TArgument>
void MaximumArgumentIsGreaterOrEqualToMinimum(TArgument&& minimumArgument, TArgument&& maximumArgument, const std::string& maximumArgumentName, std::string message)
{
    auto messageBuilder = [&message]() { return message; };
    MaximumArgumentIsGreaterOrEqualToMinimum(minimumArgument, maximumArgument, maximumArgumentName, messageBuilder);
}

After (direct implementation):

template<typename TArgument>
void MaximumArgumentIsGreaterOrEqualToMinimum(TArgument&& minimumArgument, TArgument&& maximumArgument, std::string_view maximumArgumentName, std::string_view message)
{
    if (maximumArgument < minimumArgument)
    {
        throw std::invalid_argument(std::string("Invalid ").append(maximumArgumentName).append(" argument: ").append(message).append(1, '.'));
    }
}

✅ Benefits

• Performance: Eliminated recursive function calls and lambda overhead
• Memory: std::string_view avoids unnecessary string copying for static messages
• Readability: Code is now much cleaner and easier to understand
• Maintainability: Fewer overloads and simpler logic
• Compatibility: API remains identical, no breaking changes

🧪 Testing

• Created and ran comprehensive tests to verify functionality
• All existing behavior preserved
• Exception messages remain identical
• Performance improved due to reduced overhead

📝 Notes

• Maintains the lazy evaluation concept where it's actually beneficial (dynamic message generation)
• Keeps the same API surface for backward compatibility
• Addresses the core concern raised in the issue about unnecessary complexity

🤖 Generated with Claude Code