Finally managed to create a generic solution for direct function calling. This will even work under Burst, because it allows to use calli unmanaged cdecl calls, and .NET runtime can provide us this with Marshal.GetFunctionPointerForDelegate.

Tho this call creates some wrapper and reverse P/Invoke call, on IL2CPP it's absolutely useless, so we can call this function directly.

FuncIL2CPP/FuncIL2CPPStatic provides us this ability and we can safely use it within burst and call managed land functions without any conversion.

GetUnityCaller() returns a special call which can directly call IL2CPP methods without jumping to RuntimeMethodHandle->methodPtr again in again. This caller works in cross-runtime mode, so you can use it without unity without any limitations, tho it will give very little performance penalty.

For some reason IL2CPP doesn't compile the code where TReturn is returned by ref with Fully Shared Generics enabled, this is why I'm using RefReturn struct to overcome this behavior.

P.S. Different platforms using different function pointer alignment, WebGL doesn't restricts function to be aligned by 1 byte, which means I can't use first bit to store isIL2CPP flag, while Android ARMv7 (32bit) allows functions to store last bit, so I can't use it either. So for Unity IL2CPP direct calls I've made 64-bit field for funcPtr (even on 32-bit platforms) and use last (0x8000000000000000) bit as indicator for IL2CPP direct call. To make direct il2cpp calls faster it's possible to reinterpret to AsIL2CPP() if you are sure that you are running on IL2CPP.

#if ENABLE_IL2CPP
FuncIL2CPP func = unityCall.AsIL2CPP();
#else
FuncManaged func = unityCall.AsManaged();
#endif

Unity have implemented fully generic shared function generation, when generic params could be both reference types or struct types to generate less code, but when calli opcode is encountered with an unmanaged call it will generate exception. Though it's ok because we don't need fully generic sharing, we always know argument types upfront. This exception throw will fully replace the call.
And by "fully" I mean FULLY. Yes, with returning value too. Then it referencing intptr_t L_11 which should be a return value, and since it's now non-existent, well, the variable became non-existent too leading to compile errors. This is only the case when TReturn is a reference type, of there's no TReturn at all (returning a void* for instance)