nvflinger: Emplace Display instances directly

nvdrv: Take std::string by const reference in GetDevice()

Filesystem: Return EntryType::Directory for the root directory.

hle_ipc: Amend usage of buffer_index within one of HLERequestContext's WriteBuffer() overloads

 fsp_srv: Misc individual changes

filesystem: Minor changes

common/swap: Minor changes

common/common_funcs: Remove unused rotation functions

loader/{nro, nso}: Resolve compilation warnings 

It is unknown if this is correct behavior, but it makes sense and fixes a regression with Stardew Valley.

common/misc: Deduplicate code in GetLastErrorMsg()

externals: Update Xbyak to 5.65

externals: Update catch to v2.2.3

We can use emplace_back to construct the Display instances directly,
instead of constructing them separately and copying them, avoiding the
need to copy std::string and std::vector instances that are part of the
Display struct.

file_util: return string by const reference for GetExeDirectory()

string_util: Remove AsciiToHex()

savedata_factory: Make SaveDataDescriptor's DebugInfo() function a const member function

partition_filesystem: Ensure all class members of PartitionFilesystem are initialized

content_archive: Minor changes

This is only ever used as a lookup into the device map, so we don't need to
take the std::string instance by value here.

Previously, the buffer_index parameter was unused, causing all writes to
use the buffer index of zero, which is not necessarily what is wanted
all the time.

Thankfully, all current usages don't use a buffer index other than zero,
so this just prevents a bug before it has a chance to spring.

We can avoid constructing a std::vector here by simply passing a pointer
to the original data and the size of the copy we wish to perform to the
backend's Write() function instead, avoiding copying the data where it's
otherwise not needed.

We were using a second std::vector as a buffer to convert another
std::vector's data into a byte sequence, however we can just use
pointers to the original data and use them directly with WriteBuffer,
which avoids copying the data at all into a separate std::vector.

We simply cast the pointers to u8* (which is allowed by the standard,
given std::uint8_t is an alias for unsigned char on platforms that we
support).

vfs: Deduplicate accumulation code in VfsDirectory's GetSize()

gl_state: Temporarily disable culling and depth test.

Avoids unnecessary atomic reference count incrementing and decrementing

This is simply a basic value check as opposed to potentially doing
string based operations (unlikely, but still, avoiding it is free).

This was just an artifact missed during PR review.

Prevents implicit conversions.

Gets rid of relying on indirect inclusions.

Previously we were just copying the data whole-sale, even if the length
was less than the total data size. This effectively makes the
actual_data vector useless, which is likely not intended.

Instead, amend this to only copy the given length amount of data.

At the same time, we can avoid zeroing out the data before using it by
passing iterators to the constructor instead of a size.

These are unused and essentially don't provide much benefit either. If
we ever need rotation functions, these can be introduced in a way that
they don't sit in a common_* header and require a bunch of ifdefing to
simply be available

Android and macOS have supported thread_local for quite a while, but
most importantly is that we don't even really need it. Instead of using
a thread-local buffer, we can just return a non-static buffer as a
std::string, avoiding the need for that quality entirely.

Keeps the JIT assembler library up to date and ensures we don't run into
any issues that may have been resolved.

Keeps the unit-testing library up to date.

This disallows modifying the internal string buffer (which shouldn't be
modified anyhow).