Verified with a hwtest and implemented based on reverse engineering.

Thread A's priority will get bumped to the highest priority among all the threads that are waiting for a mutex that A holds.
Once A releases the mutex and ownership is transferred to B, A's priority will return to normal and B's priority will be bumped.

They work in tandem with guest code to provide synchronization primitives along with svcArbitrateLock/Unlock

Switch mutexes are no longer kernel objects, they are managed in userland and only use the kernel to handle the contention case.
Mutex addresses store a special flag value (0x40000000) to notify the guest code that there are still some threads waiting for the mutex to be released. This flag is updated when a thread calls ArbitrateUnlock.

TODO:
* Fix svcWaitProcessWideKey
* Fix svcSignalProcessWideKey
* Remove the Mutex class.

math_util: Remove the Clamp() function

common_types: Minor changes

C++17 adds clamp() to the standard library, so we can remove ours in
favor of it.

externals: Update dynarmic to HEAD

service: Use nested namespace specifiers where applicable

common/thread: Remove unnecessary feature checking for thread_local

common_funcs: Remove check for VS versions that we don't even support

common_funcs: Remove ARRAY_SIZE macro

vector_math: Remove AsArray() and Write() functions from Vec[2,3,4]

common: Remove code_block.h

These are all unused and the Write() ones should arguably not even be in the interface. There are better ways to provide this if we ever need it (like iterators).

We use dynarmic, so this is unued. Anything else we need will likely use Xbyak, so
this header isn't necessary any more.

Every compiler we require already supports it.

C++17 has non-member size() which we can just call where necessary.

We don't support any VS versions that don't already have snprintf in the
standard library implementation.

May as well while we're making changes to this file.

VS has supported this for quite a while.

Tidies up namespace declarations

renderer_opengl: Add missing header guards

disk_filesystem: Minor changes

vi: Remove redundant initializers in the constructors

glsl_shader_decompiler: Minor API changes to ShaderWriter

ShaderGen: Fixed TEXS overriding its own texcoords and implemented fmul32i

This function doesn't need to take ownership of the string data being
given to it, considering all we do is append the characters to the
internal string instance.

Instead, use a string view to simply reference the string data without
any potential heap allocation.

Now anything that is a raw const char* won't need to be converted to a
std::string before appending.

Avoids constructing a std::string just to append a newline character

Avoids constructing a std::string just to append a character.

The interface of std::string already lets us append N copies of a
character to an existing string.