Change Pass::Run to take Program by value

Program is a move-only type, so passing by value enables callers to
transfer ownership via std::move and allows passes to return early
without cloning (e.g. the null-topology fast path just returns the
input directly).

Update PassManager to std::move programs between passes and adjust
test fixtures to use factory lambdas for repeated program creation.

Author: 1ntEgr8

csrc/setu/planner/passes/Pass.h

@@ -31,7 +31,7 @@ using setu::planner::hints::HintStore;
 class Pass : public setu::commons::NonCopyableNonMovable {
  public:
   virtual ~Pass() = default;
-  [[nodiscard]] virtual cir::Program Run(const cir::Program& program,
+  [[nodiscard]] virtual cir::Program Run(cir::Program program,
                                          const HintStore& hints) = 0;
   [[nodiscard]] virtual std::string Name() const = 0;
 };

csrc/setu/planner/passes/PassManager.cpp

@@ -28,7 +28,7 @@ void PassManager::AddPass(PassPtr pass) {
 cir::Program PassManager::Run(cir::Program program,
                               const HintStore& hints) const {
   for (const auto& pass : passes_) {
-    program = pass->Run(program, hints);
+    program = pass->Run(std::move(program), hints);
     LOG_DEBUG("After pass '{}': {}", pass->Name(), program.Dump());
   }
   return program;

csrc/setu/planner/passes/ShortestPathRouting.cpp

@@ -10,7 +10,7 @@ using setu::planner::hints::RoutingHint;
 using setu::planner::topo::Link;
 using setu::planner::topo::Path;
 
-cir::Program ShortestPathRouting::Run(const cir::Program& program,
+cir::Program ShortestPathRouting::Run(cir::Program program,
                                       const HintStore& hints) {
   // Calculate override map from routing hints
   std::map<std::pair<Participant, Participant>,

csrc/setu/planner/passes/ShortestPathRouting.h

@@ -29,7 +29,7 @@ using setu::planner::topo::TopologyPtr;
 class ShortestPathRouting : public Pass {
  public:
   explicit ShortestPathRouting(TopologyPtr topo) : topo_(std::move(topo)) {}
-  [[nodiscard]] cir::Program Run(const cir::Program& program,
+  [[nodiscard]] cir::Program Run(cir::Program program,
                                  const HintStore& hints) override;
   [[nodiscard]] std::string Name() const override {
     return "ShortestPathRouting";

csrc/test/native/cir/ShortestPathRoutingTest.cpp

@@ -95,7 +95,7 @@ TEST_F(CIRShortestPathRoutingTest, Scratch) {
 
   ShortestPathRouting pass(topo);
   HintStore hints;
-  auto program_t = pass.Run(program, hints);
+  auto program_t = pass.Run(std::move(program), hints);
 
   std::cout << "AFTER" << std::endl;
   std::cout << program_t.Dump() << std::endl;
@@ -104,7 +104,6 @@ TEST_F(CIRShortestPathRoutingTest, Scratch) {
 }
 
 TEST_F(CIRShortestPathRoutingTest, RoutingHintOverridesPath) {
-  Program program;
   auto dev0 = MakeDevice(n0, 0);
   auto dev1 = MakeDevice(n0, 1);
   auto dev2 = MakeDevice(n1, 0);
@@ -114,10 +113,14 @@ TEST_F(CIRShortestPathRoutingTest, RoutingHintOverridesPath) {
   topo->AddBidirectionalLink(dev0, dev2, Link(10, 100));
   topo->AddBidirectionalLink(dev1, dev2, Link(10, 50));
 
-  // Direct path dev0->dev2 exists, but provide a hint to route via dev1
-  auto v0 = program.EmitView(dev0, MakeEmptyShardRef(), Slice{0, 256}, dt);
-  auto v2 = program.EmitView(dev2, MakeEmptyShardRef(), Slice{0, 256}, dt);
-  (void)program.EmitCopy(v0, v2);
+  // Helper — builds the same one-copy program each time (Program is move-only)
+  auto make_program = [&]() {
+    Program p;
+    auto v0 = p.EmitView(dev0, MakeEmptyShardRef(), Slice{0, 256}, dt);
+    auto v2 = p.EmitView(dev2, MakeEmptyShardRef(), Slice{0, 256}, dt);
+    (void)p.EmitCopy(v0, v2);
+    return p;
+  };
 
   // Create a routing hint: dev0 -> dev1 -> dev2
   Path forced_path({Participant(n0, dev0.device), Participant(n0, dev1.device),
@@ -132,12 +135,12 @@ TEST_F(CIRShortestPathRoutingTest, RoutingHintOverridesPath) {
 
   // Without hints — should produce direct copy (2 hops, no intermediates)
   HintStore empty_hints;
-  auto program_no_hint = pass.Run(program, empty_hints);
+  auto program_no_hint = pass.Run(make_program(), empty_hints);
   std::cout << "WITHOUT HINT" << std::endl;
   std::cout << program_no_hint.Dump() << std::endl;
 
   // With hints — should produce multi-hop copy (3 hops, 1 intermediate)
-  auto program_with_hint = pass.Run(program, hints);
+  auto program_with_hint = pass.Run(make_program(), hints);
   std::cout << "WITH HINT" << std::endl;
   std::cout << program_with_hint.Dump() << std::endl;