refactor(model): SpellBook을 SkillBook으로 리네이밍

- 게임 컨셉에 맞게 주문서 → 스킬북 용어 통일
- 관련 모든 참조 일괄 변경

lib/src/core/engine/arena_service.dart

@@ -29,16 +29,16 @@ class ArenaService {
   // 스킬 시스템 헬퍼
   // ============================================================================
 
-  /// HallOfFameEntry의 finalSpells에서 Skill 목록 추출
+  /// HallOfFameEntry의 finalSkills에서 Skill 목록 추출
   List<Skill> _getSkillsFromEntry(HallOfFameEntry entry) {
-    final spells = entry.finalSpells;
-    if (spells == null || spells.isEmpty) return [];
+    final skillData = entry.finalSkills;
+    if (skillData == null || skillData.isEmpty) return [];
 
     final skills = <Skill>[];
-    for (final spell in spells) {
-      final spellName = spell['name'];
-      if (spellName != null) {
-        final skill = SkillData.getSkillBySpellName(spellName);
+    for (final data in skillData) {
+      final skillName = data['name'];
+      if (skillName != null) {
+        final skill = SkillData.getSkillBySpellName(skillName);
         if (skill != null) {
           skills.add(skill);
         }

lib/src/core/engine/game_mutations.dart

@@ -49,17 +49,17 @@ class GameMutations {
     final name = parts[0];
     final rank = parts.length > 1 ? parts[1] : 'I';
 
-    final spells = [...state.spellBook.spells];
-    final index = spells.indexWhere((s) => s.name == name);
+    final skills = [...state.skillBook.skills];
+    final index = skills.indexWhere((s) => s.name == name);
     if (index >= 0) {
-      spells[index] = spells[index].copyWith(rank: rank);
+      skills[index] = skills[index].copyWith(rank: rank);
     } else {
-      spells.add(SpellEntry(name: name, rank: rank));
+      skills.add(SkillEntry(name: name, rank: rank));
     }
 
     return state.copyWith(
       rng: state.rng,
-      spellBook: state.spellBook.copyWith(spells: spells),
+      skillBook: state.skillBook.copyWith(skills: skills),
     );
   }
 

lib/src/core/engine/progress_service.dart

@@ -1240,11 +1240,11 @@ class ProgressService {
 
     // 플레이어 공격 체크
     if (playerAccumulator >= playerStats.attackDelayMs) {
-      // SpellBook에서 사용 가능한 스킬 ID 목록 조회
-      var availableSkillIds = skillService.getAvailableSkillIdsFromSpellBook(
-        state.spellBook,
+      // SkillBook에서 사용 가능한 스킬 ID 목록 조회
+      var availableSkillIds = skillService.getAvailableSkillIdsFromSkillBook(
+        state.skillBook,
       );
-      // SpellBook에 스킬이 없으면 기본 스킬 사용
+      // SkillBook에 스킬이 없으면 기본 스킬 사용
       if (availableSkillIds.isEmpty) {
         availableSkillIds = SkillData.defaultSkillIds;
       }
@@ -1259,9 +1259,9 @@ class ProgressService {
       );
 
       if (selectedSkill != null && selectedSkill.isAttack) {
-        // 스펠 랭크 조회 (SpellBook 기반)
-        final spellRank = skillService.getSkillRankFromSpellBook(
-          state.spellBook,
+        // 스킬 랭크 조회 (SkillBook 기반)
+        final skillRank = skillService.getSkillRankFromSkillBook(
+          state.skillBook,
           selectedSkill.id,
         );
         // 랭크 스케일링 적용된 공격 스킬 사용
@@ -1270,7 +1270,7 @@ class ProgressService {
           player: playerStats,
           monster: monsterStats,
           skillSystem: updatedSkillSystem,
-          rank: spellRank,
+          rank: skillRank,
         );
         playerStats = skillResult.updatedPlayer;
         monsterStats = skillResult.updatedMonster;

lib/src/core/engine/skill_service.dart

@@ -552,50 +552,50 @@ class SkillService {
   }
 
   // ============================================================================
-  // SpellBook 연동
+  // SkillBook 연동
   // ============================================================================
 
-  /// SpellBook에서 사용 가능한 스킬 목록 조회
+  /// SkillBook에서 사용 가능한 스킬 목록 조회
   ///
-  /// SpellEntry 이름을 Skill로 매핑하여 반환
-  List<Skill> getAvailableSkillsFromSpellBook(SpellBook spellBook) {
-    return spellBook.spells
-        .map((spell) => SkillData.getSkillBySpellName(spell.name))
+  /// SkillEntry 이름을 Skill로 매핑하여 반환
+  List<Skill> getAvailableSkillsFromSkillBook(SkillBook skillBook) {
+    return skillBook.skills
+        .map((entry) => SkillData.getSkillBySpellName(entry.name))
         .whereType<Skill>()
         .toList();
   }
 
-  /// SpellBook에서 스킬의 랭크(레벨) 조회
+  /// SkillBook에서 스킬의 랭크(레벨) 조회
   ///
   /// 로마숫자 랭크(I, II, III)를 정수로 변환하여 반환
-  /// 스펠이 없으면 1 반환
-  int getSkillRankFromSpellBook(SpellBook spellBook, String skillId) {
+  /// 스킬이 없으면 1 반환
+  int getSkillRankFromSkillBook(SkillBook skillBook, String skillId) {
     // skillId로 스킬 찾기
     final skill = SkillData.getSkillById(skillId);
     if (skill == null) return 1;
 
-    // 스킬 이름으로 SpellEntry 찾기
-    for (final spell in spellBook.spells) {
-      if (spell.name == skill.name) {
-        return romanToInt(spell.rank);
+    // 스킬 이름으로 SkillEntry 찾기
+    for (final entry in skillBook.skills) {
+      if (entry.name == skill.name) {
+        return romanToInt(entry.rank);
       }
     }
 
     return 1; // 기본 랭크
   }
 
-  /// SpellBook에서 스킬 ID 목록 조회
+  /// SkillBook에서 스킬 ID 목록 조회
   ///
   /// 전투 시스템에서 사용 가능한 스킬 ID 목록 반환
-  List<String> getAvailableSkillIdsFromSpellBook(SpellBook spellBook) {
-    return getAvailableSkillsFromSpellBook(
-      spellBook,
+  List<String> getAvailableSkillIdsFromSkillBook(SkillBook skillBook) {
+    return getAvailableSkillsFromSkillBook(
+      skillBook,
     ).map((skill) => skill.id).toList();
   }
 
   /// 랭크 스케일링이 적용된 공격 스킬 사용
   ///
-  /// [rank] 스펠 랭크 (SpellBook에서 조회)
+  /// [rank] 스펠 랭크 (SkillBook에서 조회)
   ({
     SkillUseResult result,
     CombatStats updatedPlayer,