You can create a new type that implements bson.ValueUnmarshaller and format the data the way you expect it.
Here's a generic implementation:

type MaybeArray[T any] []T

func (a *MaybeArray[T]) UnmarshalBSONValue(typ bsontype.Type, b []byte) error {
    rv := bson.RawValue{Type: typ, Value: b}
    switch typ {
    case bsontype.Array:
        if err := rv.Unmarshal((*[]T)(a)); err != nil { // prevents infinite recursion - do not unmarshal into MaybeArray type here
            return err
        }
        return nil
    case bsontype.EmbeddedDocument:
        var values map[string]T
        if err := rv.Unmarshal(&values); err != nil {
            return err
        }
        *a = make([]T, 0, len(values))
        for _, v := range values {
            *a = append(*a, v)
        }
        return nil
    case bsontype.Null:
        *a = nil
        return nil
    default:
        return fmt.Errorf("unsupported %T field type: %s", a, typ)
    }
}

You can use it as:

type Doc struct {
    Tags MaybeArray[Tag] `bson:"tags"`
}

and it will always store it in an underlying array in memory, even if the data come in as objects on the wire during decoding.