Refactor metadata and internal data structures

Replace Metadata.h with Containers.h, introducing a HashTable
implementation with SIMD acceleration and specialized track tracking.
Cleanup PlayerEngine logic by merging it into the playback flow and
refactoring several internal API signatures.

include/Containers.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include <string>
+#include <taglib/tag.h>
+
+
+struct Metadata {
+    TagLib::String artist;
+    TagLib::String title;
+    TagLib::String album;
+    TagLib::String albumArtist;
+    unsigned int year;
+    TagLib::VariantList artwork;
+    TagLib::String genre;
+    unsigned int trackNr;
+    double length;
+    std::string format;
+    unsigned int sampleRate;
+    unsigned int bitRate;
+};
+
+struct Track {
+    TagLib::String artist;
+    TagLib::String title;
+    TagLib::String album;
+    unsigned int trackNr;
+    unsigned int length;
+    std::string filePath;
+    std::string_view artwork;
+    std::string_view genre;
+    std::string format;
+};
+
+using trackPtr = std::shared_ptr<Track>;
+
+class HashTable {
+  public:
+    static constexpr uint8_t EMPTY = 0x80;
+    static constexpr uint8_t DELETED = 0xFE;
+
+    explicit HashTable ( size_t capacity = 64 );
+
+    // delete disabled - requires rehash
+    HashTable ( const HashTable & ) = delete;
+    HashTable &operator= ( const HashTable & ) = delete;
+
+    HashTable ( HashTable && ) noexcept = default;
+    HashTable &operator= ( HashTable && ) noexcept = default;
+
+    void ht_insert ( const std::string &key, trackPtr track );
+    trackPtr ht_lookup ( const std::string &key ) const;
+    bool ht_delete ( const std::string &key );
+
+    std::vector<std::string> listAll () const;
+
+    void save ( const std::string &filename ) const;
+    std::vector<std::unique_ptr<Track>> load ( const std::string &filename );
+
+    std::size_t size () const noexcept { return size_; }
+    std::size_t capacity () const noexcept { return ctrl_.size(); }
+
+  private:
+    static constexpr double MAX_LOAD = 0.75;
+    static constexpr std::size_t GROUP_SIZE = 32;
+
+    struct Entry {
+        std::string key;
+        uint64_t hash = 0;
+        trackPtr track;
+    };
+
+    // helpers
+    static uint64_t hashString ( const std::string &key ) noexcept;
+    static uint8_t fingerprint ( uint64_t hash ) noexcept;
+    std::ptrdiff_t probe ( const std::string &key, uint64_t hash, bool insert ) const noexcept;
+    void rehash ( std::size_t newCapacity );
+
+    std::vector<uint8_t> ctrl_;
+    std::vector<Entry> entries_;
+    std::size_t size_ = 0;
+    double loadFactor_ = static_cast<double> ( size_ ) / static_cast<double> ( ctrl_.size());
+
+
+};  // Class HashTable