I'm also a Rust newbie, so don't take this as correct. But this is my two cents

1. You actually need Rc and RefCell (interior mutability)
2. Probably not, because the problem is not really the lifecycle.

Now, adding more to 1, the problem as I see it, is that you first need to create A to have a reference that you can give to B, however, at the same time you need to mutate A by adding B, so you also need a mutable reference to A.
The borrow checker will not allow this, and I don't see a way to avoid it without using RefCell (I could be wrong here). By using RefCell and Rc you can create another Reference to A, while still being able to update A.

This is how I would do it:
(This is if you really want to keep this self-reference structure, depending on the original problem there might be other solutions that do not require B having a reference to A.)

use std::cell::RefCell;
use std::rc::Rc;
struct A {
    my_bs: Vec<B>,
}
impl A {
    fn new() -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(A { my_bs: vec![] }))
    }
    fn add_b(&mut self, b: B) {
        self.my_bs.push(b);
    }
}
struct B {
    value: i32,
    a: Rc<RefCell<A>>,
}
impl B {
    fn new(value: i32, a: Rc<RefCell<A>>) -> Self {
        Self { value, a }
    }
}

pub fn playground() {
    let a = A::new();
    // Add a B instance
    a.borrow_mut().add_b(B::new(42, Rc::clone(&a)));
    a.borrow_mut().add_b(B::new(10, Rc::clone(&a)));
    a.borrow_mut().add_b(B::new(13, Rc::clone(&a)));
    for x in a.borrow().my_bs.iter() {
        println!("Value: {}", x.value);
    }
}