Resolving a lifetime issue when attempting to use fold on a vector of struct references with lifetimes

Question

I'm trying to create a parser combinator. I defined a trait and an Or parser:

trait Parser<'a> {
    fn run(&self, input: &'a str) -> (Option<&'a str>, &'a str);
}

trait Parser<'a> {
    fn run(&self, input: &'a str) -> (Option<&'a str>, &'a str);
}

pub struct Or<'a> {
    p1: &'a Parser<'a>,
    p2: &'a Parser<'a>,
}

impl<'a> Parser<'a> for Or<'a> {
    fn run(&self, input: &'a str) -> (Option<&'a str>, &'a str) {
        let (result, remainder) = self.p1.run(input);
        match result {
            Some(r) => (result, remainder),
            None => self.p2.run(input),
        }
    }
}

impl<'a> Or<'a> {
    fn new(p1: &'a Parser<'a>, p2: &'a Parser<'a>) -> Or<'a> {
        Or { p1, p2 }
    }
}

Now I want to define a Choice parser which should iterate through a vector of parsers and return a result if any of them are successful:

pub struct Choice<'a> {
    parsers: &'a Vec<&'a Parser<'a>>,
}

impl<'a> Choice<'a> {
    fn new(parsers: &'a Vec<&'a Parser<'a>>) -> Choice<'a> {
        Choice { parsers }
    }
}

impl<'a> Parser<'a> for Choice<'a> {
    fn run(&self, input: &'a str) -> (Option<&'a str>, &'a str) {
        let parser: &Parser = self.parsers
            .iter()
            .fold(&AlwaysFails::new(), |sum, p2| &Or::new(sum, p2));
        parser.run(input)
    }
}

AlwaysFails is a parser which always returns a tuple of (None, input):

pub struct AlwaysFails;

impl AlwaysFails {
    fn new() -> Self {
        AlwaysFails
    }
}

impl<'a> Parser<'a> for AlwaysFails {
    fn run(&self, input: &'a str) -> (Option<&'a str>, &'a str) {
        (None, input)
    }
}

I am getting the error

error[E0277]: the trait bound `&Parser<'a>: Parser<'_>` is not satisfied
  --> src/main.rs:40:64
   |
40 |             .fold(&AlwaysFails::new(), |sum, p2| &Or::new(sum, p2));
   |                                                                ^^ the trait `Parser<'_>` is not implemented for `&Parser<'a>`
   |
   = note: required for the cast to the object type `Parser<'_>`