Merge winners with participants (#3042)

# Description
Extracted from https://github.com/cowprotocol/services/pull/2980/files

Merges participants and winners into a single vector, which is much
easier to work with and forward around. Also reduces quite a few
roundtrips when iterating over participants to determine winning and
non-winning orders etc.

Winner selection logic is just moved into `Runloop::competition`
function so that `Participant` could become a main struct we work with
and try to even remove `RawParticipant` with refactors in the future, or
at least make it local to competition only.

# Changes
<!-- List of detailed changes (how the change is accomplished) -->

- [ ] Moved `Participants` into `domain`
- [ ] `Participants` now contain `winner` to determine if it's a winner
and allowed to settle.

## How to test
Existing e2e tests.

<!--
## Related Issues

Fixes #
-->

crates/autopilot/src/domain/competition/mod.rs

@@ -1,13 +1,14 @@
 use {
     super::auction::order,
-    crate::{
-        domain,
-        domain::{auction, eth},
-    },
+    crate::domain::{self, auction, eth},
     derive_more::Display,
     std::collections::HashMap,
 };
 
+mod participant;
+
+pub use participant::{Participant, Ranked, Unranked};
+
 type SolutionId = u64;
 
 #[derive(Debug, Clone)]

crates/autopilot/src/domain/competition/participant.rs

@@ -0,0 +1,48 @@
+use {super::Solution, crate::infra, std::sync::Arc};
+
+#[derive(Clone)]
+pub struct Participant<State = Ranked> {
+    solution: Solution,
+    driver: Arc<infra::Driver>,
+    state: State,
+}
+
+#[derive(Clone)]
+pub struct Unranked;
+pub struct Ranked {
+    is_winner: bool,
+}
+
+impl<T> Participant<T> {
+    pub fn solution(&self) -> &Solution {
+        &self.solution
+    }
+
+    pub fn driver(&self) -> &Arc<infra::Driver> {
+        &self.driver
+    }
+}
+
+impl Participant<Unranked> {
+    pub fn new(solution: Solution, driver: Arc<infra::Driver>) -> Self {
+        Self {
+            solution,
+            driver,
+            state: Unranked,
+        }
+    }
+
+    pub fn rank(self, is_winner: bool) -> Participant<Ranked> {
+        Participant::<Ranked> {
+            state: Ranked { is_winner },
+            solution: self.solution,
+            driver: self.driver,
+        }
+    }
+}
+
+impl Participant<Ranked> {
+    pub fn is_winner(&self) -> bool {
+        self.state.is_winner
+    }
+}