In the example below I will use more fresh @Observable macros instead of "old" ObservableObject protocol to avoid some complexities with view udpates.

1. Model update

struct User: Codable, Hashable {
    let id: Int
    let email: String
    let firstName: String
    let lastName: String
    let avatar: String

}

struct UserResponse: Codable {
    let data: [User]
}

@Observable
final class UserObject: Hashable, Identifiable {
    let id: Int
    let email: String
    let firstName: String
    let lastName: String
    let avatar: String

    var isFollowed: Bool

    init(id: Int, email: String, firstName: String, lastName: String, avatar: String, isFollowed: Bool = false) {
        self.id = id
        self.email = email
        self.firstName = firstName
        self.lastName = lastName
        self.avatar = avatar
        self.isFollowed = isFollowed
    }

    // Needs to conform to Hashable
    func hash(into hasher: inout Hasher) {
        hasher.combine(email)
    }

    // Needs to conform to Equatable
    static func == (lhs: UserObject, rhs: UserObject) -> Bool {
        lhs.id == rhs.id
    }
}

2. UserRow update

struct UserRow: View {
    let user: UserObject

    var body: some View {
        HStack(alignment: .top) {
            AsyncImage(url: URL(string: user.avatar)) { image in
                image
                    .resizable()
                    .scaledToFit()
                    .clipShape(Circle())
            } placeholder: {
                Circle()
                    .foregroundStyle(.ultraThinMaterial)
            }
            .frame(width: 100, height: 100)

            VStack(alignment: .leading, spacing: 16) {
                HStack {
                    Text("\(user.firstName) \(user.lastName)")
                        .font(.title3)
                        .fontWeight(.bold)
                    Spacer()
                    Button {
                        user.isFollowed.toggle()
                    } label: {
                        Text(user.isFollowed ? "Unfollow" : "Follow")
                    }
                    .buttonStyle(.borderless)
                }
                VStack(alignment: .leading) {
                    Text("Email Adress:")
                    Text(user.email)
                        .foregroundStyle(.blue)
                }

            }
            .padding(.vertical)
            .padding(.leading)
        }
    }
}

3. UserDetail udpate

struct UserDetail: View {
    let user: UserObject

    var body: some View {
        VStack {
            AsyncImage(url: URL(string: user.avatar)) { image in
                image
                    .resizable()
                    .scaledToFill()
            } placeholder: {
                Rectangle()
                    .foregroundStyle(.black)
            }
            .frame(height: 300)
            .ignoresSafeArea()

            VStack(spacing: 44) {
                Text("\(user.firstName) \(user.lastName)")
                    .font(.system(size: 40))
                    .fontWeight(.heavy)
                Text(user.email)
                    .foregroundStyle(.blue)
                Button {
                    user.isFollowed.toggle()
                } label: {
                    Text(user.isFollowed ? "Unfollow" : "Follow")
                }
                .buttonStyle(.bordered)
                .tint(.blue)
                .padding(.top, 24)
            }
            Spacer()
        }
        .navigationBarTitleDisplayMode(.inline)
    }
}

4. UserViewModel udpate

   @Observable
   final class UserViewModel {
   var users: [UserObject] = []
   var alertItem: AlertItem?
   
   func getUsers() async throws -> [User] {
       let endpoint = "https://reqres.in/api/users?page=1&per_page=15"
   
       guard let url = URL(string: endpoint) else {
           throw ReqResError.invalidURL
       }
   
       let (data, response) = try await URLSession.shared.data(from: url)
   
       guard let response = response as? HTTPURLResponse, response.statusCode == 200 else {
           throw ReqResError.invalidResponse
       }
   
       do {
           let decoder = JSONDecoder()
           decoder.keyDecodingStrategy = .convertFromSnakeCase
           let userResponse = try decoder.decode(UserResponse.self, from: data)
           return userResponse.data
       } catch {
           throw ReqResError.invalidData
       }
   }
   
   func getUsers() {
       Task {
           do {
               let receivedUsers = try await getUsers()
               users = convertUsers(receivedUsers)
   
           } catch ReqResError.invalidURL {
               print("Invalid URL")
           } catch ReqResError.invalidResponse {
               print("Invalid Response")
           } catch ReqResError.invalidData {
               print("Invalid Data")
           } catch {
               print("Unexpected Error")
           }
       }
   }
   
   // Let's convert those JSON objects to the Object we can use with isFollowed property
   func convertUsers(_ anArray: [User]) -> [UserObject] {
       var newArray = [UserObject]()
       anArray.forEach { user in
           let newUserObject = UserObject(
               id: user.id,
               email: user.email,
               firstName: user.firstName,
               lastName: user.lastName,
               avatar: user.avatar
           )
           newArray.append(newUserObject)
       }
       return newArray
   }
   }

5. ListOfUsersView udpate

struct ListOfUsersView: View {
    @State var viewModel = UserViewModel()

    var body: some View {
        NavigationStack {
            List(viewModel.users, id: \.id) { user in
                NavigationLink(value: user) {
                    UserRow(user: user)
                }
            }
            .listStyle(.grouped)
            .navigationTitle("Users")
            .navigationDestination(for: UserObject.self) { user in
                UserDetail(user: user)
            }
        }
        .alert(item: $viewModel.alertItem) { alertItem in
            Alert(title: alertItem.title, message: alertItem.message, dismissButton: alertItem.dismissButton)
        }
        .task {
            viewModel.getUsers()
        }
    }
}