Preciso instanciar novamente o EditContext se o valor for alterado?

Sim, você quer. Porque você não pode redefinir o contexto. Se você definir o contexto para um novo objeto, tudo EditForm[incluindo controles de edição] será reconstruído.

No entanto, supondo que RateItemModelseja uma classe, ou seja, um objeto de referência, sua pergunta levanta vários problemas.

1. Como você detecta se Valuemudou? As alterações de referência são aceitáveis, mas e se você alterar o objeto fora do contexto de edição. Você substituiu os comparadores iguais para sua classe de dados e, em seguida, verificou a igualdade OnParametersSet?

2. Por que mudaria Valuee o componente pai forçaria um evento em cascata de renderização? Se os renderizadores pais, então seu componente de edição será porque Valueé um objeto, então ele o renderiza porque não consegue detectar se Valuefoi alterado ou não.

Supondo que você possa detectar uma alteração, é necessário considerar dois casos:

1. O formulário atual está limpo. Como informar ao usuário que os dados foram alterados e o formulário foi recarregado?
2. O formulário atual está sujo. Como você resolve as diferenças?

Aqui está um MRE de demonstração que criei a partir de sua descrição. Fiz algumas suposições para preencher as lacunas e estou usando controles padrão em vez dos caros itens DX.

Ele usa um dicionário para rastrear os objetos de dados.

Provavelmente fornece uma visão diferente sobre como implementar o que você está tentando fazer. Há um problema se você editar um valor e depois ir para outro lugar, mas não vou mostrar como resolver isso até ter certeza de que meu MRE está bem próximo do seu caso de uso.

Meus objetos de dados:

public class Country
{
    public int Id { get; init; }  //Normally I would use a Guid, but you're probably using an int
    public string? Name { get; set; }
    public int Likes { get; set; }
    public DateTime LastEdit { get; set; } = DateTime.Now;  //dirty but quick way of tracking equality
}

// Demo Data provider
public static class CountryProvider
{
    private static List<Country> _countries = new()
        {
            new() {Id = 1, Name = "France", Likes= 1 },
            new() {Id = 2, Name = "UK", Likes= 0 },
            new() {Id = 3, Name = "Spain", Likes= 4 },
            new() {Id = 4, Name = "Portugal", Likes= 5 },
        };

    public static async Task<IEnumerable<Country>> GetCountries()
    {
        await Task.Delay(100);
        return _countries.AsEnumerable();
    }

    public static async Task SaveAsync(Country country)
    {
        // Do the save
        await Task.Delay(50);
    }
}

public record LikesData(int Id);

O cartão"

<div class="card">
    <div class="card-header">@Value.Name</div>
    <div class="card-body">
        <div class="alert alert-primary p-2 m-2"> Likes: @_model.Likes</div>
        <EditForm EditContext="_editContext" OnValidSubmit="Submit">
            <div class="input-group mb-3">
                <InputText class="form-control" @bind-Value="_model.Name" />
                <button class="btn btn-success" type="submit">Update</button>
            </div>
        </EditForm>
        <div class="m-2 text-end">
            <button class="btn btn-primary" @onclick="UpdateLikes">Like</button>
        </div>
    </div>
</div>

@code {
    [Parameter] public Country Value { get; set; } = new();
    [Parameter] public EventCallback<Country> ValueChanged { get; set; }
    [Parameter] public EventCallback<LikesData> LikesChanged { get; set; }

    private EditContext? _editContext;
    private Country _model = new();

    // This is here so we have all our data sorted before any first render
    public override Task SetParametersAsync(ParameterView parameters)
    {
        parameters.SetParameterProperties(this);

        ArgumentNullException.ThrowIfNull(this.Value);

        // Timestamp used to track edit state.  You can use what mechanism you like
        // I use value objects for all my data simplifying equality checking
        // Country would be public record Country{};
        // and here i would create a CountryEditContext object for editing
        if (this.Value.LastEdit != _model.LastEdit)
        {
            _model = new()
                {
                    Id = this.Value.Id,
                    Name = this.Value.Name,
                    Likes = this.Value.Likes,
                    LastEdit = this.Value.LastEdit,
                };
            _editContext = new(_model);
        }

        return base.SetParametersAsync(ParameterView.Empty);
    }

    //Your return object may be more complex so I've used a value object rather than just an int
    private async Task UpdateLikes()
    {
        await this.LikesChanged.InvokeAsync(new(this.Value.Id));
    }

    // Form submit on validation.
    private async Task Submit()
    {
        _model.LastEdit = DateTime.Now;
        await this.ValueChanged.InvokeAsync(_model);
    }
}

E a página:

<div class="row">
    @foreach(var country in _countries )
    {
        <div class="col-12 col-md-6 col-lg-4">
            <CountryCard @key="country.Value.Id"
            Value="country.Value" 
            ValueChanged="this.UpdateCountry" 
            LikesChanged="this.UpdateLikes" />
        </div>
    }
</div>

@code {

    // use a dictionary so we can separate out the index from the object and only replace the object on an update
    private Dictionary<int, Country> _countries = new();

    protected override async Task OnInitializedAsync()
    {
        var countries = await CountryProvider.GetCountries();
        // normally need to check here if you have a list here and do something if you don't
        foreach(var country in countries)
            _countries.Add(country.Id, country);
    }

    private async  Task UpdateCountry(Country country)
    {
        _countries[country.Id] = country;
        await CountryProvider.SaveAsync(country);
    }

    private void UpdateLikes(LikesData value)
    {
        _countries[value.Id].Likes++;
        _countries[value.Id].LastEdit = DateTime.Now;
    }
}