* GDBStub works with both Unicorn and Dynarmic now

* Tidy up

This was intermixing signed and unsigned values when they could all just
be signed.

We can just use the file interfaces that Qt provides to prevent needing
to convert to std::string.

The codec used by Qt for const char* and std::string don't necessarily
have to be the same depending on locale. Therefore, we should be using
the correct functions to do the conversions.

There's no need to keep these separate from one another.

Given the function accepts a boolean, we don't need to use an if
statement here and repeat ourselves.

In OnMenuRecentFile() we don't need to construct a QFileInfo instance
just to check if a file exists, we can just use the static member
function to do that (which Qt's documentation also notes as quicker than
constructing an instance).

In UpdateUITheme(), we just want to try and open the file and check the
success of that operation. Technically speaking, between the existence
check and the open call, the file can be deleted or moved, but still
appear to succeed in code. i.e.

1. Existence check -> Returns true
2. File is moved/deleted
3. Open is called, the return value of which isn't checked
4. Nonsense behavior

This way we combine the existence check and the open into one.

Previously, when canceling out of the Load Folder dialog, a user would
get an error dialog about the selected folder not containing a main
file, however, by canceling out of the dialog, no selection was actually
made.

These occur automatically without the need to call them. While we're at
it, also std::move the QString instance into its member variable.

Makes code consistent with our style of defaulting special member
functions where applicable.

Instead we can simply provide accessors to the required data instead of
giving external read/write access to the variables directly.

ms is shorthand for milliseconds, not microseconds, and given there's no
comment indicating that this was intentional, it probably wasn't.

Enforces the time unit being returned and also allows using the standard
time utilities to manipulate it.

Keeps the code consistent.

Previously, the prototype wasn't matching the definition, which has a
Processor parameter before the destination address.

These aren't necessary, as value-wise const only matters in the
definition.

Makes the alias a little more readable from left-to-right.

Gets rid of the need to hardcode the type in multiple places. This will
now be deduced automatically, based off the elements in the container
being provided to the algorithm.

Eliminates duplicate code shared between their Load methods, after all the only difference is how the romfs is handled.

Rather than having to type out the full std::map type signature, we can
just use a straightforward alias. While we're at it, rename
GetBreakpointList to GetBreakpointMap, which makes the name more
accurate. We can also get rid of unnecessary u64 static_casts, since
VAddr is an alias for a u64.

Keeps everything under the same namespace. While we're at it, enclose
them all within an inner anonymous namespace.

In all cases the vector being supplied is empty, so we can just return
by value in these instances.

In all cases, a virtual address is being passed in, not a physical one.

Adds the basic skeleton of the arp services based off the information
provided by Switch Brew.

These don't do anything within .cpp files (we don't include cpp files,
so...)

These functions should only be given trivially-copyable types.

This function doesn't directly depend on class state, so it can be
hidden entirely from the interface in the cpp file.

This doesn't modify member state, so it can be made const.