¿Siempre es necesario usar weak o unowned en la lista…

No, no siempre.

Weak y unowned se utilizan para prevenir ciclos de referencias fuertes (retain cycles) en cierres, cuando el cierre mantiene una referencia fuerte a un objeto, y el objeto a su vez mantiene una referencia fuerte al cierre.

Es necesario usar weak o unowned cuando el cierre captura una referencia fuerte a self u otro tipo referencial, y existe la probabilidad de que se produzca un ciclo de referencias fuertes.

Situaciones en las que no es necesario usar weak/unowned:

El cierre captura tipos de valor (estructuras, enumeraciones, tuplas). Se copian al capturar, y no se generan ciclos de referencias fuertes.
El cierre captura un tipo referencial, pero no existe una referencia fuerte bidireccional. Por ejemplo, si el cierre se crea localmente dentro de un método y no se guarda en un objeto al que hace referencia.
El cierre tiene una vida corta y se ejecutará antes de que el objeto al que hace referencia sea liberado. Por ejemplo, un cierre pasado a un método como un manejador de finalización que se ejecuta inmediatamente.

Elección entre weak y unowned:

weak: Se usa cuando el objeto capturado puede volverse nil en cualquier momento antes de que se ejecute el cierre. La referencia se declara como opcional (ObjectType?). Requiere verificar nil antes de usar.
unowned: Se usa cuando se sabe que el objeto capturado siempre existirá en el momento de la ejecución del cierre. La referencia no es opcional (ObjectType). No requiere verificar nil. Usar unowned en un objeto que se vuelve nil provocará un error en tiempo de ejecución.

// Ejemplo donde no se necesita weak/unowned (captura de estructura)
struct MyStruct {
    var value: Int
}

let myStruct = MyStruct(value: 10)
let closure = {
    print(myStruct.value) // Captura una copia de myStruct
}
closure()

// Ejemplo donde no se necesita weak/unowned (cierre local)
class MyClass {
    func doSomething() {
        let localValue = 5
        let localClosure = {
            print(self.description) // Captura self, pero el cierre no se guarda en MyClass
        }
        localClosure()
    }

    var description: String {
        return "Instance of MyClass"
    }
}

let myObject = MyClass()
myObject.doSomething()

// Ejemplo donde se necesita weak (potencialmente nil)
class AsyncOperation {
    var completionHandler: (() -> Void)?

    func performOperation() {
        // Simulación de trabajo asíncrono
        DispatchQueue.global().async {
            print("Operation completed")
            self.completionHandler?() // Encadenamiento opcional
        }
    }

    deinit {
        print("AsyncOperation deinitialized")
    }
}

class ViewController {
    var op: AsyncOperation?

    func setupOperation() {
        op = AsyncOperation()
        op?.completionHandler = { [weak self] in // weak self
            guard let self = self else { return }
            print("Completion handler in ViewController: \(self)")
        }
    }

    deinit {
        print("ViewController deinitialized")
    }
}

// Ejemplo donde se necesita unowned (garantizado existe)
class Button {
    var action: (() -> Void)?

    func tap() {
        action?()
    }

    deinit {
        print("Button deinitialized")
    }
}

class ViewControllerWithButton {
    var button: Button

    init() {
        button = Button()
        button.action = { [unowned self] in // unowned self
            print("Button tapped in ViewControllerWithButton: \(self)")
        }
    }

    deinit {
        print("ViewControllerWithButton deinitialized")
    }
}

¿Siempre es necesario usar weak o unowned en la lista de captura?