feat: Refactor move ordering logic to improve gain calculation and simplify exchange handling

modules/bot/src/main/scala/de/nowchess/bot/logic/MoveOrdering.scala

@@ -108,7 +108,7 @@ object MoveOrdering:
       val initialGain = victimValue(context, move)
       movedPieceAfterMove(context, move).fold(initialGain) { moved =>
         val boardAfterMove = applySeeMove(context.board, move, moved)
-        exchangeGain(boardAfterMove, target, context.turn.opposite, pieceValue(moved), Vector(initialGain))
+        initialGain - seeGain(boardAfterMove, target, context.turn.opposite, pieceValue(moved))
       }
 
   private def movedPieceAfterMove(context: GameContext, move: Move): Option[Piece] =
@@ -116,21 +116,13 @@ object MoveOrdering:
       case MoveType.Promotion(pp) => Some(Piece(context.turn, promotionPieceType(pp)))
       case _                      => context.board.pieceAt(move.from)
 
-  @tailrec
-  private def exchangeGain(board: Board, target: Square, side: Color, capturedValue: Int, gains: Vector[Int]): Int =
+  private def seeGain(board: Board, target: Square, side: Color, currentValue: Int): Int =
     leastValuableAttacker(board, target, side) match
-      case None => resolveGain(gains)
+      case None => 0
       case Some((from, attacker)) =>
-        val nextGain  = capturedValue - gains.last
         val nextBoard = board.removed(from).updated(target, attacker)
-        exchangeGain(nextBoard, target, side.opposite, pieceValue(attacker), gains :+ nextGain)
-
-  private def resolveGain(gains: Vector[Int]): Int =
-    (gains.length - 2 to 0 by -1)
-      .foldLeft(gains) { (acc, idx) =>
-        acc.updated(idx, math.max(acc(idx), -acc(idx + 1)))
-      }
-      .head
+        val replyGain = seeGain(nextBoard, target, side.opposite, pieceValue(attacker))
+        math.max(0, currentValue - replyGain)
 
   private def applySeeMove(board: Board, move: Move, moved: Piece): Board =
     move.moveType match