[python][iron] ObjectFifo: emit per-handle depth ArrayAttr instead of collapsing equal depths

Cherry-picks the python-side change from upstream PR Xilinx#3096 ("Fix
objectfifo declared depth as minimum"). IRON's ObjectFifo previously
collapsed `[prod_depth, *cons_depths]` to a single int when all values
were equal, which the `aie-objectFifo-stateful-transform` lowering
interpreted as "producer depth only" and silently auto-minimized each
consumer's ping-pong from max-acquire -- dropping below the user's
declared depth.

For multi-consumer fanout with uneven acquire patterns (one consumer
must buffer ahead of a peer that's waiting on upstream data), the
auto-minimize sized every pool to 2 (ping-pong) regardless of what
.cons(depth=N) requested, deadlocking at runtime.

Concrete symptom hit in this branch: yolo26n m6 (c3k2_heavy) bot_fifo
fanout to m_0_split AND cv3_cv2. ObjectFifo declared depth=6,
.cons(depth=6) on both consumers, but lowered IR allocated 2 buffers
per pool and m6 standalone TIMEOUT'd. After the fix the producer pool
gets 6 buffers, each consumer pool gets 6 buffers, and m6 runs bit-
exact at 66.9 fps. m2 (c3k2_small, same fanout pattern, also depth=6
+ .cons(depth=6)x2) was getting prod=6/cons=4 pre-fix (some other
auto-sizing path); post-fix it gets the full 6 everywhere and m2 perf
goes 62.4 -> 69.7 fps as a side effect.

Test included upstream: `test/python/objFifo_iron_multi_cons_depth.py`.

Co-Authored-By: Claude Opus 4 (1M context) <noreply@anthropic.com>

Author: hunhoffe

python/iron/dataflow/objectfifo.py

@@ -267,20 +267,6 @@ def _cons_tiles_ops(self) -> list[Tile]:
             )
         return [cons.endpoint.tile.op for cons in self._cons]
 
-    def _get_depths(self) -> int | list[int]:
-        if not self._prod:
-            raise ValueError(
-                "Cannot return depths since prod ObjectFifoHandle is not created."
-            )
-        if len(self._cons) == 0:
-            raise ValueError(
-                "Cannot return depths since no cons ObjectFifoHandles are created."
-            )
-        depths = [self._prod.depth] + [con.depth for con in self._cons]
-        if len(set(depths)) == 1:
-            return depths[0]
-        return depths
-
     def _get_endpoint(self, is_prod: bool) -> list[ObjectFifoEndpoint]:
         if is_prod:
             if self._prod:
@@ -304,11 +290,27 @@ def resolve(
                 for con in self._cons
             ]
 
+            if not self._prod:
+                raise ValueError(
+                    f"ObjectFifo {self.name}: producer handle not created."
+                )
+            if len(self._cons) == 0:
+                raise ValueError(
+                    f"ObjectFifo {self.name}: no consumer handles created."
+                )
+            # Always emit the per-handle ArrayAttr [prod_depth, *cons_depths].
+            # Collapsing to a single int when all are equal triggers the
+            # stateful-transform's auto-minimize path, which sizes each
+            # consumer's ping-pong from max-acquire instead of honoring the
+            # declared depth -- silently deadlocking multi-consumer fanout
+            # designs where one consumer must buffer ahead of the others.
+            depths = [self._prod.depth] + [con.depth for con in self._cons]
+
             self._op = object_fifo(
                 self.name,
                 self._prod_tile_op(),
                 self._cons_tiles_ops(),
-                self._get_depths(),
+                depths,
                 np_ndarray_type_to_memref_type(self._obj_type),
                 dimensionsToStream=self._dims_to_stream,
                 dimensionsFromStreamPerConsumer=dims_from_stream_per_cons,