Retain nested types referenced only by sibling method signatures

[danwood]

Symptom

A nested type that is used only as the return type or a parameter type of a sibling method in the same enclosing type is incorrectly reported as unused, even when the enclosing type is reachable. For example:

public struct Container {
    public init() {}

    func makeResult() -> Payload { Payload() }   // Payload flagged unused
    func consume(_: Mode) {}                      // Mode flagged unused

    struct Payload {}
    enum Mode { case one }
}

Payload and Mode are reported unused despite appearing in the method signatures.

Root cause

The Swift index store records the type reference for a return/parameter type against the method declaration; it does not emit a standalone reference occurrence for the type itself. UsedDeclarationMarker.markUsed(_:) follows a declaration's own references and related, but it does not descend into the signature-type references held by the declaration's child functions. So when the enclosing type is marked used, a nested type reachable only through a sibling method's signature has no incoming reference to follow and is left unmarked.

Fix

When a declaration is marked used, also walk the returnType and parameterType references of its child function declarations and mark the referenced declarations used. This retains nested types that appear only in sibling method signatures, without affecting types reachable through ordinary references.

Tests

Adds testRetainsNestedTypeUsedAsSiblingMethodSignatureType, with a fixture containing a nested struct used as a method return type and a nested enum used as a method parameter type, reachable only through those signatures. The test fails before the change (both nested types reported unused) and passes after. The full existing suite continues to pass with no regressions.