feat(pipeline): add WSKL (Wowee Skill Catalog) format

Novel open replacement for Blizzard's SkillLine.dbc +
SkillLineCategory.dbc + the AzerothCore-style player skill
base tables. The 19th open format added to the editor.

Defines every player-trackable skill: weapon proficiencies
(Swords, Axes, Bows), professions (Mining, Alchemy,
Cooking), languages (Common, Dwarvish), class
specializations (Fire, Frost, Holy, Protection), armor
proficiencies (Mail, Plate), and secondary skills (First
Aid, Lockpicking, Riding).

Cross-references with previously-added formats:
  WLCK.channel.targetId (kind=Lockpick) -> WSKL.entry.skillId
  WGOT.entry.requiredSkill              -> WSKL.entry.skillId

The starter preset's skillIds 186 (Mining) and 633
(Lockpicking) deliberately match the canonical IDs already
referenced by WGOT.makeGather and WLCK.makeDungeon —
so the demo content stack now wires together end-to-end:
WGOT herb-node requires skill 186 -> WSKL Mining at rank 1+;
WLCK bandit-strongbox channel requires skill 633 -> WSKL
Lockpicking at rank 1+.

Format:
  • magic "WSKL", version 1, little-endian
  • per skill: skillId / name / description / categoryId /
    canTrain / maxRank / rankPerLevel / iconPath

Enums:
  • CategoryId (8): Weapon / Class / Profession /
    SecondaryProfession / Language / ArmorProficiency /
    Riding / WeaponSpec

API: WoweeSkillLoader::save / load / exists / findById;
presets makeStarter (5-skill demo with cross-referenced
canonical IDs), makeProfessions (12 classic professions:
9 primary + 3 secondary), makeWeapons (16 weapon skills
with canonical SkillLine IDs and rankPerLevel=5 auto-grow).

CLI added (5 flags, 528 documented total now):
  --gen-skills / --gen-skills-professions / --gen-skills-weapons
  --info-wskl / --validate-wskl

Validator catches: skillId=0 + duplicates, empty name,
maxRank=0, unknown categoryId, suspicious maxRank=1 on
non-Language skill (only languages cap at 1), weapon skill
with rankPerLevel=0 (won't auto-grow on use).

src/pipeline/wowee_skills.cpp

@@ -0,0 +1,225 @@
+#include "pipeline/wowee_skills.hpp"
+
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+
+namespace wowee {
+namespace pipeline {
+
+namespace {
+
+constexpr char kMagic[4] = {'W', 'S', 'K', 'L'};
+constexpr uint32_t kVersion = 1;
+
+template <typename T>
+void writePOD(std::ofstream& os, const T& v) {
+    os.write(reinterpret_cast<const char*>(&v), sizeof(T));
+}
+
+template <typename T>
+bool readPOD(std::ifstream& is, T& v) {
+    is.read(reinterpret_cast<char*>(&v), sizeof(T));
+    return is.gcount() == static_cast<std::streamsize>(sizeof(T));
+}
+
+void writeStr(std::ofstream& os, const std::string& s) {
+    uint32_t n = static_cast<uint32_t>(s.size());
+    writePOD(os, n);
+    if (n > 0) os.write(s.data(), n);
+}
+
+bool readStr(std::ifstream& is, std::string& s) {
+    uint32_t n = 0;
+    if (!readPOD(is, n)) return false;
+    if (n > (1u << 20)) return false;
+    s.resize(n);
+    if (n > 0) {
+        is.read(s.data(), n);
+        if (is.gcount() != static_cast<std::streamsize>(n)) {
+            s.clear();
+            return false;
+        }
+    }
+    return true;
+}
+
+std::string normalizePath(std::string base) {
+    if (base.size() < 5 || base.substr(base.size() - 5) != ".wskl") {
+        base += ".wskl";
+    }
+    return base;
+}
+
+} // namespace
+
+const WoweeSkill::Entry* WoweeSkill::findById(uint32_t skillId) const {
+    for (const auto& e : entries) {
+        if (e.skillId == skillId) return &e;
+    }
+    return nullptr;
+}
+
+const char* WoweeSkill::categoryName(uint8_t c) {
+    switch (c) {
+        case Weapon:              return "weapon";
+        case Class:               return "class";
+        case Profession:          return "profession";
+        case SecondaryProfession: return "secondary";
+        case Language:            return "language";
+        case ArmorProficiency:    return "armor";
+        case Riding:              return "riding";
+        case WeaponSpec:          return "weapon-spec";
+        default:                  return "unknown";
+    }
+}
+
+bool WoweeSkillLoader::save(const WoweeSkill& cat,
+                            const std::string& basePath) {
+    std::ofstream os(normalizePath(basePath), std::ios::binary);
+    if (!os) return false;
+    os.write(kMagic, 4);
+    writePOD(os, kVersion);
+    writeStr(os, cat.name);
+    uint32_t entryCount = static_cast<uint32_t>(cat.entries.size());
+    writePOD(os, entryCount);
+    for (const auto& e : cat.entries) {
+        writePOD(os, e.skillId);
+        writeStr(os, e.name);
+        writeStr(os, e.description);
+        writePOD(os, e.categoryId);
+        writePOD(os, e.canTrain);
+        uint8_t pad[2] = {0, 0};
+        os.write(reinterpret_cast<const char*>(pad), 2);
+        writePOD(os, e.maxRank);
+        writePOD(os, e.rankPerLevel);
+        writeStr(os, e.iconPath);
+    }
+    return os.good();
+}
+
+WoweeSkill WoweeSkillLoader::load(const std::string& basePath) {
+    WoweeSkill out;
+    std::ifstream is(normalizePath(basePath), std::ios::binary);
+    if (!is) return out;
+    char magic[4];
+    is.read(magic, 4);
+    if (std::memcmp(magic, kMagic, 4) != 0) return out;
+    uint32_t version = 0;
+    if (!readPOD(is, version) || version != kVersion) return out;
+    if (!readStr(is, out.name)) return out;
+    uint32_t entryCount = 0;
+    if (!readPOD(is, entryCount)) return out;
+    if (entryCount > (1u << 20)) return out;
+    out.entries.resize(entryCount);
+    for (auto& e : out.entries) {
+        if (!readPOD(is, e.skillId)) { out.entries.clear(); return out; }
+        if (!readStr(is, e.name) || !readStr(is, e.description)) {
+            out.entries.clear(); return out;
+        }
+        if (!readPOD(is, e.categoryId) ||
+            !readPOD(is, e.canTrain)) {
+            out.entries.clear(); return out;
+        }
+        uint8_t pad[2];
+        is.read(reinterpret_cast<char*>(pad), 2);
+        if (is.gcount() != 2) { out.entries.clear(); return out; }
+        if (!readPOD(is, e.maxRank) ||
+            !readPOD(is, e.rankPerLevel)) {
+            out.entries.clear(); return out;
+        }
+        if (!readStr(is, e.iconPath)) {
+            out.entries.clear(); return out;
+        }
+    }
+    return out;
+}
+
+bool WoweeSkillLoader::exists(const std::string& basePath) {
+    std::ifstream is(normalizePath(basePath), std::ios::binary);
+    return is.good();
+}
+
+WoweeSkill WoweeSkillLoader::makeStarter(const std::string& catalogName) {
+    WoweeSkill c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t cat,
+                   uint16_t maxRank, uint16_t perLevel,
+                   uint8_t train) {
+        WoweeSkill::Entry e;
+        e.skillId = id; e.name = name;
+        e.categoryId = cat; e.maxRank = maxRank;
+        e.rankPerLevel = perLevel; e.canTrain = train;
+        c.entries.push_back(e);
+    };
+    add(43,  "Swords",         WoweeSkill::Weapon,             300, 5, 1);
+    add(98,  "Common",         WoweeSkill::Language,             1, 0, 0);
+    add(129, "First Aid",      WoweeSkill::SecondaryProfession, 300, 0, 1);
+    // SkillId 186 = Mining, 633 = Lockpicking — the canonical
+    // values that WGOT.makeGather and WLCK.makeDungeon already
+    // reference.
+    add(186, "Mining",         WoweeSkill::Profession,         300, 0, 1);
+    add(633, "Lockpicking",    WoweeSkill::SecondaryProfession, 300, 0, 1);
+    return c;
+}
+
+WoweeSkill WoweeSkillLoader::makeProfessions(const std::string& catalogName) {
+    WoweeSkill c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name, uint8_t cat) {
+        WoweeSkill::Entry e;
+        e.skillId = id; e.name = name;
+        e.categoryId = cat; e.maxRank = 300; e.canTrain = 1;
+        c.entries.push_back(e);
+    };
+    // Primary professions (canonical SkillLine IDs).
+    add(164, "Blacksmithing",  WoweeSkill::Profession);
+    add(165, "Leatherworking", WoweeSkill::Profession);
+    add(171, "Alchemy",        WoweeSkill::Profession);
+    add(182, "Herbalism",      WoweeSkill::Profession);
+    add(186, "Mining",         WoweeSkill::Profession);
+    add(197, "Tailoring",      WoweeSkill::Profession);
+    add(202, "Engineering",    WoweeSkill::Profession);
+    add(333, "Enchanting",     WoweeSkill::Profession);
+    add(393, "Skinning",       WoweeSkill::Profession);
+    // Secondary professions.
+    add(129, "First Aid",      WoweeSkill::SecondaryProfession);
+    add(185, "Cooking",        WoweeSkill::SecondaryProfession);
+    add(356, "Fishing",        WoweeSkill::SecondaryProfession);
+    return c;
+}
+
+WoweeSkill WoweeSkillLoader::makeWeapons(const std::string& catalogName) {
+    WoweeSkill c;
+    c.name = catalogName;
+    auto add = [&](uint32_t id, const char* name) {
+        WoweeSkill::Entry e;
+        e.skillId = id; e.name = name;
+        e.categoryId = WoweeSkill::Weapon;
+        e.maxRank = 300;        // matches character-level cap × 5
+        e.rankPerLevel = 5;     // weapon skill auto-grows by 5/level
+        e.canTrain = 0;         // weapons train via use, not trainer
+        c.entries.push_back(e);
+    };
+    // Canonical SkillLine IDs from WoW classic.
+    add( 43, "Swords");
+    add( 44, "Axes");
+    add( 45, "Bows");
+    add( 46, "Guns");
+    add( 54, "Maces");
+    add( 55, "Two-Handed Swords");
+    add( 95, "Defense");
+    add(118, "Daggers");
+    add(136, "Staves");
+    add(160, "Two-Handed Maces");
+    add(172, "Two-Handed Axes");
+    add(173, "Polearms");
+    add(176, "Thrown");
+    add(226, "Crossbows");
+    add(228, "Wands");
+    add(473, "Fist Weapons");
+    return c;
+}
+
+} // namespace pipeline
+} // namespace wowee