Uses a std::string_view instead of a std::string, given the pointed to
string isn't modified and is only used in a formatting operation.

This is nice because a few usages directly supply a string literal to
the function, allowing these usages to otherwise not heap allocate,
unlike the std::string overloads.

While we're at it, we can combine the address formatting into a single
formatting call.

Now that all of our code is compilable with implicit QString
conversions, we can enforce it at compile-time by disabling them.

This isn't actually used anywhere, so it can be removed.

Given the std::optional can contain an object type that heap allocates,
we can use std::move to avoid an unnecessary copy/allocation from
occurring.

Qt uses a signed value to represent container sizes, so this was causing
a sign mismatch warning.

Allows the software keyboard applet code to compile with implicit string
conversions disabled.

Allows the error applet to build successfully with implicit string
conversions disabled.

This allows for forming comment nodes without making unnecessary copies
of the std::string instance.

e.g. previously:

Comment(fmt::format("Base address is c[0x{:x}][0x{:x}]",
        cbuf->GetIndex(), cbuf_offset));

Would result in a copy of the string being created, as CommentNode()
takes a std::string by value (a const ref passed to a value parameter
results in a copy).

Now, only one instance of the string is ever moved around. (fmt::format
returns a std::string, and since it's returned from a function by value,
this is a prvalue (which can be treated like an rvalue), so it's moved
into Comment's string parameter), we then move it into the CommentNode
constructor, which then moves the string into its member variable).

Keeps the shader code file endings consistent.

Amends cases where we were using things that were indirectly being
satisfied through other headers. This way, if those headers change and
eliminate dependencies on other headers in the future, we don't have
cascading compilation errors.

This accidentally slipped through a rebase.

Given the array is a private static array, we can just make it
internally linked to hide it from external code. This also allows us to
remove an inclusion within the header.

Allows the configuration code to build successfully with implicit string
conversions disabled.

Allows the game list code to compile successfully with implicit string
conversions disabled.

Allows the game list worker code to compile successfully with implicit
string conversions disabled.

SMDH is a metadata format used in some executable formats for the
Nintendo 3DS. Switch executables don't utilize this metadata format, so
this just a holdover from Citra and can be corrected.

Allows the game list item code to build with implicit string conversions
disabled.

Allows the loading screen code to compile with implicit string
conversions disabled.

While we're at it remove unnecessary const usages, and add it to nearby
variables where appropriate.

Allows the bootmanager code to compile with implicit string conversions
disabled.

Allows the util code to build with implicit string conversions disabled.

Gets rid of the need to special-case brace handling depending on the
overload used, and makes it consistent across the board with how fmt
handles them.

Strings with compile-time deducible strings are directly forwarded to
std::string's constructor, so we don't need to worry about the
performance difference here, as it'll be identical.

This reverts a tested behavior on delay slots not exiting if the exit 
flag is set. Currently new tests are required in order to ensure this 
behavior.

In a lot of places throughout the decompiler, string concatenation via
operator+ is used quite heavily. This is usually fine, when not heavily
used, but when used extensively, can be a problem. operator+ creates an
entirely new heap allocated temporary string and given we perform
expressions like:

std::string thing = a + b + c + d;

this ends up with a lot of unnecessary temporary strings being created
and discarded, which kind of thrashes the heap more than we need to.
Given we utilize fmt in some AddLine calls, we can make this a part of
the ShaderWriter's API. We can make an overload that simply acts as a
passthrough to fmt.

This way, whenever things need to be appended to a string, the operation
can be done via a single string formatting operation instead of
discarding numerous temporary strings. This also has the benefit of
making the strings themselves look nicer and makes it easier to spot
errors in them.

Allows the web config code to compile with implicit string conversions
disabled. We can also deduplicate the calls to create the pixmap.

Allows the system config code to build successfully with implicit string
conversions disabled.

This is a user-facing string, so it should be marked as translatable.

Allows the per-game configuration to be successfully built with implicit
string conversions disabled.

Deduplicates array accesses and uses a named variable where appropriate.

Allows the advanced mouse configuration code to build with implicit
string conversions disabled.

Rather than repeatedly index arrays that have quite a large array index,
we can just use a named variable instead.

Allows the player input configuration code to compile with implicit
string conversions disabled.

These are user-facing strings, so they should be localizable.