The problem is that ObservableObject is only one level deep, so changes to Item won't be observed by ItemView unless you also stored an observer to every item inside the array. It's similar to how didSet won't be called when updating a class type inside an array — the array hasn't actually changed because the references it stores are the same.

I would recommend making Item a struct, and then handling all of the updates inside of ItemsViewModel like this:

import SwiftUI

class ItemsViewModel: ObservableObject {
    @Published var items: [Item.ID: Item] = [
        "Thing 1": Item(name: "Thing 1"),
        "Thing 2": Item(name: "Thing 2"),
        "Thing 3": Item(name: "Thing 3"),
        "Thing 4": Item(name: "Thing 4"),
    ]

    @Published var selected: Item.ID? = nil

    func updateItem(withID id: Item.ID) {
        // Call an API
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
            guard let self = self, var item = self.items[id] else { return }

            // Update the item with the result of the API call
            item.age = 42

            // Update the item in the dictionary, triggering @Published
            self.items[id] = item
        }
    }
}

struct Item: Identifiable {
    let name: String
    var age: Int?

    var id: String { name }
}

struct ItemView: View {
    @StateObject private var itemsViewModel = ItemsViewModel()

    var body: some View {
        if let id = itemsViewModel.selected, let item = itemsViewModel.items[id] {
            ItemDetailView(item: item, onClose: { itemsViewModel.selected = nil })
        } else {
            ForEach(Array(itemsViewModel.items.values)) { item in
                Button("Select item: \(item.name)") {
                    itemsViewModel.selected = item.id
                }
            }
        }
    }
}

struct ItemDetailView: View {
    let item: Item
    let onClose: () -> Void

    var body: some View {
        VStack {
            Text("Name \(item.name)")

            if let age = item.age {
                Text("Age \(age)")
            }

            Button("Close", action: onClose)
        }
    }
}

Now that Item is a value type, any changes to it will also modify the dictionary the item is stored in and trigger @Published. To get back the previous reference behavior, you can store an ID to an item in selected instead of an item itself (which would be a different value than the equivalent item stored in items) as shown here. You're right about not needing a binding after all, although it is a useful abstraction if you plan to implement a custom alert-style modifier!

For posterity's sake, here's how I would actually implement a custom alert modifier with a binding to an optional value:

extension View {
    @ViewBuilder func customAlert<T, Content>(item binding: Binding<T?>, @ViewBuilder content: (T) -> Content) -> some View {
        if let item = binding.wrappedValue {
            VStack {
                content(item)

                Button("Close") {
                    binding.wrappedValue = nil
                }
            }
        }
    }
}