Performance fixes

[brainplot]

Type of change

• ✅ Bug fix (non-breaking change which fixes an issue)

Description and Context

Just a few more performance improvements spotted thanks to Clang-Tidy and Clazy.

• Use QFileInfo's exists() static method
  According to the docs, this static method is faster than the instance method of the same class. I simply replaced it accordingly.

• Replace QMap with QHash when the key is a pointer:
  In a map where the key is a pointer, hash-based lookups are faster than tree-based lookups, as you only have to compute the hash of a number which is an O(1) operation, as opposed to the O(log(n)) complexity of the Red-Black tree of QMaps.

• Avoid copying QSharedPointers when not needed
  Many QSharedPointers were passed by value even though they did not modify the object pointed to in any way. They have been changed to const QSharedPointer<*>&. Also a few copies were avoided thanks to std::move().
  Actually I took a while to inspect the code a little more carefully and to me it feels like they can all be QScopedPonters or std::unique_ptrs passed by const reference (i.e. without taking ownership) but I didn't want to change that because I thought I may be missing something so I'm just bringing this up for now waiting for your feedback.

• Avoid creation of temporary containers
  I know we've discussed this already but I couldn't figure out why the static analyzer kept complaining about the creation of temporary containers. It turns out that Qt containers may detach when used as rvalues in a loop. These code examples show that containers must be used as a const lvalue to make sure they won't detach. Basically, by simply storing them in a const variable did the trick in the case of rvalues, using asConst in core/Global.h worked for lvalues; now the static analyzer no longer shows the warnings about temporary containers.
  To prove that, I set up Qt in a local instance of Compiler Explorer and gave it this test code:

#include <QtGlobal>
#include <QMap>
#include <QString>

static const QMap<QString, QString> deprecationMap = {
    // >2.3.4
    {"security/hidepassworddetails", "security/HidePasswordPreviewPanel"},
    // >2.3.4
    {"GUI/HideDetailsView", "GUI/HidePreviewPanel"},
    // >2.3.4
    {"GUI/DetailSplitterState", "GUI/PreviewSplitterState"},
    // >2.3.4
    {"security/IconDownloadFallbackToGoogle", "security/IconDownloadFallback"},
};

void upgrade()
{
    const auto keys = deprecationMap.keys(); // <--
    for (const auto& setting : keys) {
        qWarning("%s\n", setting);
    }
}

The Assembly produced by this was 50 lines shorter than the same code using deprecationMap.keys() in the loop directly. (compiled with gcc -O3)

• Wrap static literal strings with QStringLiteral
  The QStrings in the deprecation map were implicitly constructed with the const char* constructor which creates a dynamically-allocated string. The map, however, is used in read-only mode and the values are all known at compile time so they can be allocated statically with QStringLiteral.

Testing strategy

I ran all existing tests and they all passed.

Checklist:

• ✅ I have read the CONTRIBUTING document. [REQUIRED]
• ✅ My code follows the code style of this project. [REQUIRED]
• ✅ All new and existing tests passed. [REQUIRED]
• ✅ I have compiled and verified my code with -DWITH_ASAN=ON. [REQUIRED]

[droidmonkey]

Can you please rebase this on the newly formatted code. Make sure to run "make format" before you push.

[brainplot]

Done! 👍