Why Are My SwiftUI List Item Animations Inconsistent When Moving Elements Between Sections?

I'm exploring SwiftUI and learning about view identity, and I’ve run into some confusing, inconsistent animations when moving elements between sections in a list.

I have two examples that behave differently. In the first example, one version (currently commented out) fails to animate the movement of a view smoothly, while the uncommented version animates as expected. Here’s the code:

SWIFTCopied
import SwiftUI

struct SwitchView: View {
  enum SwitchLocation {
    case top, bottom

    mutating func toggle() {
      switch self {
      case .top:
        self = .bottom
      case .bottom:
        self = .top
      }
    }
  }
  @State var location: SwitchLocation = .top

  var body: some View {
    VStack {
      Text("TOP")

      // This version does not smoothly animate the view from top to bottom and back. The other
//      if self.location == .top {
//        Text("My Position")
//          .onTapGesture {
//            withAnimation {
//              self.location.toggle()
//            }
//          }
//        Spacer()
//      } else {
//        Spacer()
//        Text("My Position")
//          .onTapGesture {
//            withAnimation {
//              self.location.toggle()
//            }
//          }
//      }

      // This version DOES animate smoothly between locations, and it makes sense to me.
      Text("My Position")
        .frame(maxHeight: .infinity, alignment: self.location == .top ? .top : .bottom)
        .onTapGesture {
          withAnimation {
            self.location.toggle()
          }
        }

      Text("BOTTOM")
    }
  }
}

The second example involves a List with two sections (rescue dogs and adopted dogs) that are updated by tapping on a row. I expected the dog row to animate smoothly between sections. Instead, the animation only works smoothly about 50% of the time—with the other half of the cases simply fading in and out. Here’s that code:

SWIFTCopied
import SwiftUI

struct Dog {
  var id = UUID()
  var name: String
}

class BestDogRoster: ObservableObject {
  private var rescueDogNames: [String] = ["Milo", "Archer", "Theo", "Talula", "Zavvi"]
  private var adoptedDogNames: [String] = ["Henry", "Auggie"]
  @Published var rescueDogs: [Dog] = []
  @Published var adoptedDogs: [Dog] = []
  
  init() {
    self.rescueDogs = rescueDogNames.map({
      Dog(name: $0)
    })
    self.adoptedDogs = adoptedDogNames.map({
      Dog(name: $0)
    })
  }
  
  func adoptDog(at index: Int) {
    adoptedDogs.append(rescueDogs.remove(at: index))
  }
  
  func giveUpDog(at index: Int) {
    rescueDogs.append(adoptedDogs.remove(at: index))
  }
}

struct BestContentView: View {
  @ObservedObject var dogRoster = BestDogRoster()
  
  var body: some View {
    List {
      Section {
        ForEach(Array(dogRoster.rescueDogs.enumerated()), id: \.offset) { index, dog in
          Text(dog.name)
            .onTapGesture {
              withAnimation {
                dogRoster.adoptDog(at: index)
              }
            }
        }
      }
      Section("Adopted Dogs") {
        ForEach(Array(dogRoster.adoptedDogs.enumerated()), id: \.offset) { index, dog in
          Text(dog.name)
            .onTapGesture {
              withAnimation {
                dogRoster.giveUpDog(at: index)
              }
            }
        }
      }
    }
  }
}

I've also tried generating arrays of Text views directly instead of arrays of Dog objects, but the behavior remains the same. My question is whether there's a better best practice for "moving" an element between two list sections than simply using oneArray.append(secondArray.remove(at: index)), or if I might be missing another SwiftUI technique to achieve smooth animations consistently.

I appreciate any feedback or suggestions on how to resolve these inconsistent animations.