问SwiftUI -多层深度NavigationLink无法工作

EN

struct ContentView: View {
    @State
    var navigationList: NavigationList?

    var body: some View {
        NavigationView {
            Navigatable(list: $navigationList) {
                Button("Push test", action: {
                    navigationList = .init(next: nil, screen: Screen {
                        TestView()
                    })
                })
            }
        }
    }
}

struct TestView: View {
    @Environment(\.navigationList)
    @Binding
    var list
    
    var body: some View {
        Button("Push me", action: {
            list = .init(next: nil, screen: Screen {
                TestView()
            })
        })
    }
}

struct Navigatable<Content: View>: View {
    @Binding
    var list: NavigationList?
    let content: () -> Content

    init(list: Binding<NavigationList?>, @ViewBuilder content: @escaping () -> Content) {
        self._list = list
        self.content = content
    }

    var body: some View {
        ZStack {
            NavigationLink(
                isActive: isActive,
                destination: {
                    Navigatable<Screen?>(list: childBinding) {
                        list?.screen
                    }
                }, 
                label: EmptyView.init
            ).hidden()
            LazyView {
                content()
            }.environment(\.navigationList, $list)
        }
    }
    
    var isActive: Binding<Bool> {
        .init(
            get: { list != nil },
            set: {
                if !$0 {
                    list = nil
                }
            }
        )
    }
    
    var childBinding: Binding<NavigationList?> {
        .init(
            get: { list?.next },
            set: { list?.next = $0 }
        )
    }
}

struct Screen: View {
    let content: () -> AnyView
    
    init<C: View>(@ViewBuilder content: @escaping () -> C) {
        self.content = {
            .init(content())
        }
    }
    
    var body: some View {
        content()
    }
}

struct NavigationList {
    @Indirect
    var next: NavigationList?
    
    let screen: Screen
}


enum NavigationListKey: EnvironmentKey {
    static var defaultValue: Binding<NavigationList?> {
        .constant(nil)
    }
}

extension EnvironmentValues {
    var navigationList: Binding<NavigationList?> {
        get { self[NavigationListKey.self] }
        set { self[NavigationListKey.self] = newValue }
    }
}

struct LazyView<Content: View>: View {
    @ViewBuilder var content: () -> Content
    
    var body: some View {
        content()
    }
}

@propertyWrapper
struct Indirect<Wrapped> {
    private final class Storage: CustomReflectable {
        var wrapped: Wrapped
        
        init(_ wrapped: Wrapped) {
            self.wrapped = wrapped
        }
        
        var customMirror: Mirror {
            .init(self, children: [(label: "wrapped", value: wrapped)])
        }
    }
    
    private let storage: Storage
    
    var wrappedValue: Wrapped {
        get { storage.wrapped }
        mutating set { storage.wrapped = newValue }
    }
    
    init(wrappedValue: Wrapped) {
        self.storage = .init(wrappedValue)
    }
}