MMIO: Cleanup Mapping class by using templates instead of macros.

The MMIO mapping interface was using lots of macros before to use the same code for different MMIO register sizes. This branch replaces the macro usage with templates.

Macros aren't a particular modern way of using C++ to begin with, but in this case I think using templates instead of macros indeed makes the code a lot more readable. Additionally, I was able to clean up the interface a lot because the C++ overloading restrictions don't affect templated code.

For what it's worth, I'm not sure if

    template<typename Unit>
    struct HandlerArray
    {
        using Read = std::array<ReadHandler<Unit>, NUM_MMIOS / sizeof(Unit)>;
        using Write = std::array<WriteHandler<Unit>, NUM_MMIOS / sizeof(Unit)>;
    };

    HandlerArray<u8>::Read m_read_handlers8;
    HandlerArray<u16>::Read m_read_handlers16;
    HandlerArray<u32>::Read m_read_handlers32;

    HandlerArray<u8>::Write m_write_handlers8;
    HandlerArray<u16>::Write m_write_handlers16;
    HandlerArray<u32>::Write m_write_handlers32;
is any cleaner than

    std::array<ReadHandler<u8>, NUM_MMIOS / sizeof(Unit)> m_read_handlers8;
    std::array<ReadHandler<u16>, NUM_MMIOS / sizeof(Unit)> m_read_handlers16;
    std::array<ReadHandler<u32>, NUM_MMIOS / sizeof(Unit)> m_read_handlers32;

    std::array<WriteHandler<u8>, NUM_MMIOS / sizeof(Unit)> m_write_handlers8;
    std::array<WriteHandler<u16>, NUM_MMIOS / sizeof(Unit)> m_write_handlers16;
    std::array<WriteHandler<u32>, NUM_MMIOS / sizeof(Unit)> m_write_handlers32;
Opinions on that? (having written this in comparison, I got to say myself that the second version is probably better)

For reference, the version of this code living in current master is

    #define HANDLERS(Size) \
    std::array<ReadHandler<u##Size>, NUM_MMIOS / sizeof (u##Size)> m_Read##Size##Handlers; \
    std::array<WriteHandler<u##Size>, NUM_MMIOS / sizeof (u##Size)> m_Write##Size##Handlers;
    HANDLERS(8) HANDLERS(16) HANDLERS(32)
    #undef HANDLERS
I've just checked this. GCC produces completely equivalent assembly. I had some troubles testing the same for MSVC, however as far as I can see there should be no performance issues.

The assembly code generated by MSVC is roughly a 1000 lines longer, which confused me a bit. However, it seems that most of these lines come from template instantiations (tuple, tie, get), all of which aren't ever `call`ed because they are inlined (and properly optimized, as far as I can see). Alas, maybe I'm just reading the assembly wrong. @shuffle2 maybe you can take a quick look over it to check that I'm not talking nonsense here?
https://dl.dolphin-emu.org/nbx/temp/MemmapFunctions_old.asm <-- assembly generated for the old code
https://dl.dolphin-emu.org/nbx/temp/MemmapFunctions_mine.asm <-- assembly generated for the code in this PR
https://dl.dolphin-emu.org/nbx/temp/MemmapFunctions_mine_forceinline.asm <-- assembly generated for the code in this PR + all the MMIO::Mapping methods force-inlined (which is probably the road we should go).