file_sys/control_metadata: Get rid of magic constants

These are just the size of the data being passed in, so we can specify
that via the size() member function.

aoc: Fix various bugs in current AOC implementation

nro/nso: Minor error handling changes

crypto: Various crypto fixes for quickstart guide

If a malformed NSO is attempted to be loaded, we shouldn't continue
onwards. We should be reporting an error and bailing out.

video_core: Minor style changes

Control Code 0xf means to unconditionally execute the instruction. This
value is passed to most BRA, EXIT and SYNC instructions (among others)
but this may not always be the case.

This function doesn't need to care about ownership semantics, so we can
just pass it a reference to the file itself, rather than a
std::shared_ptr alias.

Falls back to title ID + 0x1000, which is what HOS does.

key_manager/partition_data_manager: Minor changes

yuzu/main: Simplify OnMenuLoadFile()

video_core: Added ASTC 5x4; 8x5 types

filesystem: Make CreateFactories() and InstallInterface() take a VfsFilesystem by reference

Introduce 3D Swizzle seamlessly 

svc: Implement svcGetProcessInfo

Stop all threads on svcBreak

This should help diagnose crashes easier and prevent many users thinking that a game is still running when in fact it's just an audio thread still running(this is typically not killed when svcBreak is hit since the game expects us to do this)

A fairly basic service function, which only appears to currently support
retrieving the process state. This also alters the ProcessStatus enum to
contain all of the values that a kernel process seems to be able of
reporting with regards to state.

filesystem: Make CreateFactories() and InstallInterface() take a VfsFilesystem instance by reference

Neither of these functions alter the ownership of the provided pointer,
so we can simply make the parameters a reference rather than a direct
shared pointer alias. This way we also disallow passing incorrect memory values like
nullptr.

We can utilize QStringList's join() function to perform all of the
appending in a single function call.

While we're at it, make the extension list a single translatable string
and add a disambiguation comment to explain to translators what %1
actually is.

We can just reserve the memory then perform successive insertions
instead of needing to use memcpy. This also avoids the need to zero out
the output vector's memory before performing the insertions.

We can also std::move the output std::vector into the destination so
that we don't need to make a completely new copy of the vector, getting
rid of an unnecessary allocation.

Additionally, we can use iterators to determine the beginning and end
ranges of the std::vector instances that comprise the output vector, as
the end of one range just becomes the beginning for the next successive
range, and since std::vector's iterator constructor copies data within
the range [begin, end), this is more straightforward and gets rid of the
need to have an offset variable that keeps getting incremented to
determine where to do the next std::memcpy.

Aside from emplacing elements into the map, the map itself is never
actually queried for contained data.

These are only ever read from, so we don't need to make a copy of all
the keys here.

Given it's only used in one spot and has a fairly generic name, we can
just specify it directly in the function call. This also the benefit of
automatically moving it.

Commented out code shouldn't be left in without a reason indicating why
in a comment.

Instead, we can make it part of the type and make named variables for
them, so they only require one definition (and if they ever change for
whatever reason, they only need to be changed in one spot).