rust 蚀生命周期 不匹配不一定超过此处定义的生命周期

The first problem with your code is that your trait definition and the actual implementation don't match in their signature, one method does have a lifetime parameter, the other doesn't, this is what the compiler complains about.
To fix this you can just double check that both methods have the same signature (I personally always copy & paste the signature over from the trait's definition or let the LSP server do that for me).

然后有一个问题，&'a Foo<'a>通常是一种代码气味，它实际上从来不是实际的生存期，而且只在少数情况下是可以的.除非您知道您在做什么，否则您应该总是从每个生存期的不同生存期开始，这样编译器就可以准确地告诉您它认为这些生存期是如何关联的.

You don't actually want your borrows to be limited by the reference to the Foo, after all you want to move the reference from it and use that longer lifetime, but that's impossible if you artificially force 'a and 'b of &'a Foo<'b> to be the same by reusing 'a for the inner lifetime.
To fix this replace &'a Foo<'a> with &Foo<'a> everywhere (the outer lifetime can be elided in all places you used it)

The third problem is that your trait definitions don't allow for your requirements, you can't have a function be generic over a lifetime and at the same time fix that same lifetime to some lifetime from the implementation.
To fix it change Visitor and DataBorrowed to accept a lifetime parameter:

pub trait Visitor<'a> {
    type Value;
    fn visit_table_borrowed(&mut self, t: &Foo<'a>) {
        let _ = t;
    }
}

pub trait DataBorrowed<'a> {
    fn accept<V: Visitor<'a>>(&self, visitor: &mut V);
}

下面是一个完整的版本，解决了所有三个问题:

use serde::{Deserialize, Serialize};

#[derive(Deserialize, Debug, Serialize)]
pub struct Foo<'a> {
    name: &'a str,
}

impl<'a> Foo<'a> {
    pub fn new(name: &'a str) -> Self {
        Self { name }
    }
}

#[derive(Deserialize, Debug, Serialize)]
pub struct Bar<'a> {
    name: &'a str,
}

impl<'a> Bar<'a> {
    pub fn new(name: &'a str) -> Self {
        Self { name }
    }
}

pub trait Visitor<'a> {
    type Value;
    fn visit_table_borrowed(&mut self, t: &Foo<'a>) {
        let _ = t;
    }
}

pub trait DataBorrowed<'a> {
    fn accept<V: Visitor<'a>>(&self, visitor: &mut V);
}

impl<'a> DataBorrowed<'a> for Foo<'a> {
    fn accept<V: Visitor<'a>>(&self, visitor: &mut V) {
        visitor.visit_table_borrowed(self)
    }
}

impl<'a> Visitor<'a> for Bar<'a> {
    type Value = Bar<'a>;
    fn visit_table_borrowed(&mut self, t: &Foo<'a>) {
        self.name = t.name;
    }
}

impl<'a> From<Foo<'a>> for Bar<'a> {
    fn from(dt: Foo<'a>) -> Self {
        let mut table = Bar::new("bar");
        dt.accept(&mut table);
        table
    }
}

fn main() {
    let f = Foo::new("foo");
    let b: Bar = Bar::from(f);
}