Refactor ce_mcp_bridge.lua into a thinner Lua bridge with more logic moved to Python

[sirebacon]

I wanted to open up a discussion on how to handle ce_mcp_bridge.lua being really big. I wanted to see if it would be best to extract out the really complicated logic and have modularized, scalable tool sets in python that can communicate with the lua file. That way managing and building out tool sets become easier to debug and fix. The AI agents will speak to a the python application which can reduce down the amount of tokens that get sent off to the AI.

[sirebacon]

● CURRENT STATE
─────────────────────────────────────────────────────────────────────

┌─────────────┐        ┌────────────────────────────────────────┐
│  AI Client  │◄──────►│         mcp_cheatengine.py             │
│  (Claude)   │  stdio │  (thin wrappers, mostly pass-through)  │
└─────────────┘        └──────────────────┬─────────────────────┘
                                          │ Named Pipe
                       ┌──────────────────▼─────────────────────┐
                       │          ce_mcp_bridge.lua              │
                       │                                         │
                       │  ● Pipe I/O + CE main-thread dispatch   │
                       │  ● Memory read/write/scan               │
                       │  ● Breakpoints, symbols, injection      │
                       │  ● Multi-step workflow logic        ◄── │─── too much
                       │  ● Result ranking & scoring         ◄── │─── in Lua
                       │  ● Validation & error formatting    ◄── │
                       │  ● Convenience wrappers             ◄── │
                       │  ● String/encoding cleanup          ◄── │
                       └──────────────────┬─────────────────────┘
                                          │ CE Lua API
                       ┌──────────────────▼─────────────────────┐
                       │            Cheat Engine                 │
                       └─────────────────────────────────────────┘

PROPOSED STATE
─────────────────────────────────────────────────────────────────────

┌─────────────┐        ┌────────────────────────────────────────┐
│  AI Client  │◄──────►│         mcp_cheatengine.py             │
│  (Claude)   │  stdio │                                        │
└─────────────┘        │  ● Multi-step workflow logic      ◄──  │
                       │  ● Result ranking & scoring       ◄──  │  logic moves
                       │  ● Validation & error formatting  ◄──  │  here
                       │  ● Convenience wrappers           ◄──  │
                       │  ● String/encoding cleanup        ◄──  │
                       │  ● Orchestration                  ◄──  │
                       └──────────────────┬─────────────────────┘
                                          │ Named Pipe
                       ┌──────────────────▼─────────────────────┐
                       │       ce_mcp_bridge.lua  (thinner)      │
                       │                                         │
                       │  ● Pipe I/O + CE main-thread dispatch   │
                       │  ● Memory read/write/scan               │
                       │  ● Breakpoints, symbols, injection      │
                       │  ● Resource ownership & cleanup         │
                       │  ● Structured result return             │
                       └──────────────────┬─────────────────────┘
                                          │ CE Lua API
                       ┌──────────────────▼─────────────────────┐
                       │            Cheat Engine                 │
                       └─────────────────────────────────────────┘

DECISION GUIDE (unit-by-unit review)
─────────────────────────────────────────────────────────────────────

STAYS IN LUA                      MOVES TO PYTHON
──────────────────────────────    ──────────────────────────────
read/write memory                 scoring & ranking logic
AOB scanning                      multi-step scan workflows
breakpoints (HW + SW)             retry / fallback orchestration
symbol registration               result filtering & formatting
code injection                    validation of input params
disassembly (raw)                 higher-level analysis wrappers
pipe framing & dispatch           convenience tool composition
CE main/worker thread boundary    encoding & string cleanup
resource cleanup (RAII-style)     test-friendly business logic

This captures the current problem (one overloaded Lua file), the target (thin Lua bridge + richer Python
layer), and the per-unit decision criteria for the review pass.

The one real risk:
Round-trip cost. Every time Python needs something from CE, it crosses the Named Pipe. If a workflow
currently does 10 CE calls in Lua with no pipe overhead, moving it to Python means 10 pipe round-trips
instead. For anything in a tight loop or time-sensitive (like a scan that calls CE repeatedly), that
latency adds up.

The practical middle ground:

• Move orchestration, scoring, formatting → Python (no CE API calls, pure logic — zero cost to move)
• Keep anything that loops over CE API calls in Lua, but have it return a clean structured result rather
  than doing the interpretation itself
• The boundary question isn't just "Lua vs Python" — it's "does this need to call CE APIs in a loop?"