feat: Added Linux support to the Process Memory Provider (#1331)

<!--
Please provide as much information as possible about what your PR aims
to do.
PRs with no description will most likely be closed until more
information is provided.
If you're planing on changing fundamental behaviour or add big new
features, please open a GitHub Issue first before starting to work on
it.
If it's not something big and you still want to contact us about it,
feel free to do so !
-->

### Problem description
<!-- Describe the bug that you fixed/feature request that you
implemented, or link to an existing issue describing it -->
Implement a Linux backend for the ProcessMemoryProvider plugin.

### Implementation description
<!-- Explain what you did to correct the problem -->
Most of the provider code is the same between Windows and Linux. The
primary differences are:
- enumerate PIDs in `/proc/` to get the process list
- use `/proc/<PID>/cmdline` as the process name
- parse `/proc/<PID>/maps` to get the module list
- reading/writing from memory is done using
`process_vm_readv`/`process_vm_writev`

NOTE: `sudo setcap CAP_SYS_PTRACE=+eip build/imhex` must be run to give
the binary permission to read another process' memory. Running as root
user should also work but I would not recommend it.

### Additional things
The existing translations keys no longer match since I moved the plugin
from `windows` to `builtin`.

I'm not well versed in C++ so I attempted to keep my changes rather
simple. Feedback is very welcome.

---------

Co-authored-by: WerWolv <werwolv98@gmail.com>

plugins/builtin/include/content/providers/process_memory_provider.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+#if defined(OS_WINDOWS) || defined (OS_LINUX)
+
+#include <hex/providers/provider.hpp>
+#include <hex/api/localization_manager.hpp>
+
+#include <hex/ui/imgui_imhex_extensions.h>
+#include <hex/ui/widgets.hpp>
+#include <hex/helpers/utils.hpp>
+
+#include <set>
+#include <thread>
+
+#include <nlohmann/json.hpp>
+
+#if defined(OS_WINDOWS)
+    #include <windows.h>
+#elif defined(OS_LINUX)
+    #include <sys/types.h>
+#endif
+
+namespace hex::plugin::builtin {
+
+    class ProcessMemoryProvider : public hex::prv::Provider {
+    public:
+        ProcessMemoryProvider() = default;
+        ~ProcessMemoryProvider() override = default;
+
+        [[nodiscard]] bool isAvailable() const override {
+            #ifdef _WIN32
+                return this->m_processHandle != nullptr;
+            #elif __linux__
+                return this->m_processId != -1;
+            #endif
+        }
+        [[nodiscard]] bool isReadable() const override { return true; }
+        [[nodiscard]] bool isWritable() const override { return true; }
+        [[nodiscard]] bool isResizable() const override { return false; }
+        [[nodiscard]] bool isSavable() const override { return false; }
+        [[nodiscard]] bool isDumpable() const override { return false; }
+
+        void readRaw(u64 address, void *buffer, size_t size) override;
+        void writeRaw(u64 address, const void *buffer, size_t size) override;
+        [[nodiscard]] u64 getActualSize() const override { return 0xFFFF'FFFF'FFFF;  }
+
+        void save() override {}
+
+        [[nodiscard]] std::string getName() const override { return hex::format("hex.builtin.provider.process_memory.name"_lang, this->m_selectedProcess != nullptr ? this->m_selectedProcess->name : ""); }
+        [[nodiscard]] std::vector<Description> getDataDescription() const override {
+            return {
+                    { "hex.builtin.provider.process_memory.process_name"_lang, this->m_selectedProcess->name },
+                    { "hex.builtin.provider.process_memory.process_id"_lang, std::to_string(this->m_selectedProcess->id) }
+            };
+        }
+
+        [[nodiscard]] bool open() override;
+        void close() override;
+
+        [[nodiscard]] bool hasLoadInterface() const override { return true; }
+        [[nodiscard]] bool hasInterface() const override { return true; }
+        bool drawLoadInterface() override;
+        void drawInterface() override;
+
+        void loadSettings(const nlohmann::json &) override {}
+        [[nodiscard]] nlohmann::json storeSettings(nlohmann::json) const override { return { }; }
+
+        [[nodiscard]] std::string getTypeName() const override {
+            return "hex.builtin.provider.process_memory";
+        }
+
+        [[nodiscard]] std::pair<Region, bool> getRegionValidity(u64) const override;
+        std::variant<std::string, i128> queryInformation(const std::string &category, const std::string &argument) override;
+
+    private:
+        void reloadProcessModules();
+
+    private:
+        struct Process {
+            u32 id;
+            std::string name;
+            ImGuiExt::Texture icon;
+        };
+
+        struct MemoryRegion {
+            Region region;
+            std::string name;
+
+            constexpr bool operator<(const MemoryRegion &other) const {
+                return this->region.getStartAddress() < other.region.getStartAddress();
+            }
+        };
+
+        std::vector<Process> m_processes;
+        const Process *m_selectedProcess = nullptr;
+
+        std::set<MemoryRegion> m_memoryRegions;
+        ui::SearchableWidget<Process> m_processSearchWidget = ui::SearchableWidget<Process>([](const std::string &search, const Process &process) {
+            return hex::containsIgnoreCase(process.name, search);
+        });
+        ui::SearchableWidget<MemoryRegion> m_regionSearchWidget = ui::SearchableWidget<MemoryRegion>([](const std::string &search, const MemoryRegion &memoryRegion) {
+            return hex::containsIgnoreCase(memoryRegion.name, search);
+        });
+
+#ifdef _WIN32
+        HANDLE m_processHandle = nullptr;
+#elif __linux__
+        pid_t m_processId = -1;
+#endif
+
+        bool m_enumerationFailed = false;
+    };
+
+}
+
+#endif