size the output buffer per item instead of per building

Implements the requirements from 8401b20. OutputBuffer's type-blind `capacity`
becomes a `caps` map keyed by item, mirroring InputBuffer. The items stay in
one production-ordered vector, because that order is what the output port hands
out (REQ-MAT-OUTPUT-EMERGE); only the capacity is now per type, so one item's
backlog no longer occupies another's room.

The cycle gate moves ahead of the roll in tickProduction: recipeOutputsFit()
requires every output a cycle could produce to fit, which for a deterministic
recipe is just its own outputs and for the Reprocessing Plant is every possible
roll. That is what denies the reroll the old one-item cap was there for -- a
full buffer for one item stops the plant entirely rather than letting it keep
producing the others -- while letting it hold two cycles' worth per outcome and
produce amounts above one.

getCycleOutputItemCount(), which judged the plant by the smallest amount any
roll could yield, is gone: it only existed because the classifier could not know
the roll, and the all-outcomes rule needs no such approximation. Its unlock
caveat goes with it, since a locked item is never produced and so never fills.

The Salvage Bay's config-defined capacity becomes its single scrap cap, and the
shipyard simply has no caps at all. The checksum hashes the map the way the
input caps are hashed, so determinism is unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ne3mejABZoLWKLh8fgpM3x

src/lib/sim/ProductionRules.cpp

@@ -1,47 +1,13 @@
 #include "ProductionRules.h"
 
 #include <algorithm>
-#include <limits>
+#include <map>
 
 #include "BuildingType.h"
 #include "ItemType.h"
 #include "ModulesConfig.h"
 #include "ShipsConfig.h"
 
-namespace
-{
-
-// Items one cycle of this recipe would deposit into the output buffer. A Reprocessing
-// Plant rolls exactly one of its outputs per cycle (REQ-BLD-REPROCESSING) and the roll
-// happens in the simulation, so the smallest amount any roll could yield is what decides
-// whether a cycle could start at all; a larger roll may still not fit.
-int getCycleOutputItemCount(const Building& b, const RecipeDef& recipe)
-{
-    if (recipe.outputs.empty())
-    {
-        return 0;
-    }
-
-    if (b.type == BuildingType::ReprocessingPlant)
-    {
-        int smallest = std::numeric_limits<int>::max();
-        for (const RecipeOutput& out : recipe.outputs)
-        {
-            smallest = std::min(smallest, out.amount);
-        }
-        return smallest;
-    }
-
-    int total = 0;
-    for (const RecipeOutput& out : recipe.outputs)
-    {
-        total += out.amount;
-    }
-    return total;
-}
-
-}  // namespace
-
 std::vector<const RecipeDef*>
 gatherCandidateRecipes(const GameConfig& config, const Building& b)
 {
@@ -177,9 +143,44 @@ bool hasInputsToStart(const GameConfig& config, const Building& b)
     return false;
 }
 
-bool outputBufferHasRoom(const Building& b, int outputItemCount)
+bool outputBufferHasRoom(const Building& b, const ItemType& type, int itemCount)
 {
-    return b.getOutputItemCount() + outputItemCount <= b.outputBuffer.capacity;
+    const std::map<ItemType, int>::const_iterator capIt = b.outputBuffer.caps.find(type);
+    const int cap = (capIt != b.outputBuffer.caps.end()) ? capIt->second : 0;
+    return b.getOutputItemCount(type) + itemCount <= cap;
+}
+
+bool recipeOutputsFit(const Building& b, const RecipeDef& recipe)
+{
+    if (b.type == BuildingType::ReprocessingPlant)
+    {
+        // One roll yields one of these, so each is measured on its own -- but all of them
+        // have to fit, since which one it will be is not known yet.
+        for (const RecipeOutput& out : recipe.outputs)
+        {
+            if (!outputBufferHasRoom(b, ItemType{out.item}, out.amount))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // A deterministic cycle deposits all of its outputs together. An item listed more
+    // than once is produced in the sum of those amounts, so it is judged once, as a sum.
+    std::map<ItemType, int> perCycle;
+    for (const RecipeOutput& out : recipe.outputs)
+    {
+        perCycle[ItemType{out.item}] += out.amount;
+    }
+    for (const std::pair<const ItemType, int>& entry : perCycle)
+    {
+        if (!outputBufferHasRoom(b, entry.first, entry.second))
+        {
+            return false;
+        }
+    }
+    return true;
 }
 
 bool canStartCycle(const GameConfig& config, const Building& b)
@@ -193,8 +194,7 @@ bool canStartCycle(const GameConfig& config, const Building& b)
 
     for (const RecipeDef* recipe : gatherCandidateRecipes(config, b))
     {
-        if (recipeInputsAvailable(b, *recipe)
-            && outputBufferHasRoom(b, getCycleOutputItemCount(b, *recipe)))
+        if (recipeInputsAvailable(b, *recipe) && recipeOutputsFit(b, *recipe))
         {
             return true;
         }