MVVM: ViewModels for bidirectional model elements

Assume I have following Model structure:

class Team {
    public string Name {get;set; }
    public List<Player> players {get;set;}
}

class Player {
    public int Age {get;set;}
    public string Name {get;set;}
    public Team Team {get;set;}
}

I wish to create Viewmodels for this model. However, I also would like to avoid duplicating all properties from Player in the TeamVM and vice versa (for this simple example this would be feasable, but in reality rather cumbersome).

Looking at the literature and online articles, it seems that the "Pure" way would be to create a ViewModel for each Model and to have a ViewModel only retu other ViewModels and never Models. This is all fine, but my problem is: how do you create these viewmodels without getting into a recursion trap. Assume I do it like this:

public class TeamVM: ViewModel<Team> {

   private ObservableCollection<PlayerVM> _players;

   public TeamVM(Team t): base(t) {
       _players = new ObservableCollection();
       foreach (Player p in t.players) {
          _players.Add(new PlayerVM(t));
       }
   }

   public string Name {
      get { retu _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }

   public ObservableCollection<PlayerVM> Players {
      get { retu _players; }
   }
}

and

public class PlayerVM : ViewModel<Player> {

   private TeamVM _teamVM;

   public PlayerVM(Player p): base(p) {
       _teamVm = new TeamVM(p.Team);
   }

   public int Age {
      get { retu _modelElement.Age; }
      set { _modelElement.Age = value; NotifyPropertyChanged(); }
   }
   public string Name {
      get { retu _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }
   public TeamVM Team {
      get { retu _teamVM; }
      set { _teamVm = value; NotifyPropertyChanged(); }
   }
}

Obviously, the above can never work, since it creates recursion: creation of a TeamVM results in the creation of PlayerVMs which in tu spawn TeamVMs again etc.

Right now, I have solved this, by adding an intermediate class as follows:

public class TeamMinimalVM: ViewModel<Team> {

   public TeamVM(Team t): base(t) {
   }

   public string Name {
      get { retu _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }
}

public class TeamVM: TeamMinimalVM {

   private ObservableCollection<PlayerVM> _players;

   public TeamVM(Team t): base(t) {
       _players = new ObservableCollection();
       foreach (Player p in t.players) {
          _players.Add(new PlayerVM(t));
       }
   }
}

And then having PlayerVM depend on TeamMinimalVM instead of TeamVM. This means that in the views, you would be able to do: {Binding Player.Team.Name} but not {Binding Player.Team.Players.Name}, which is kind of ok for me I guess since I don't think it's a great idea to do this anyway.

My question now is: is there a better/more "standard" way to do "Pure" VMs of bidirectional model elements? I do not want to clone properties of one type in the other (there are too many), nor do I want to expose Model elements directly.

Finally, the ViewModel class I use is this one (just for completeness, but it is not essential to the question I think.)

public class ModelElementViewModel<T> : ObservableObject where T : class 
{
    private bool _modelElementChanged;
    private T _modelElement;

    public ModelElementViewModel(T element)
    {
        _modelElement = element;
    }

    /// <summary>
    /// The underlying model element for this viewmodel. Protected as one should not bind directly to model elements from the gui.
    /// </summary>
    inteal T ModelElement {
        get { retu _modelElement; }
        set {
            if (_modelElement != value)
            {
                _modelElement = value;
                ModelElementChanged = false;
                NotifyAllPropertiesChanged();
            }
            ; }
    }

    /// <summary>
    /// Property that can be used to see if the underlying modelelement was changed through this viewmodel (note that an exteal 
    /// change to the model element is not tracked!)
    /// </summary>
    public bool ModelElementChanged {
        private set
        {
            if (_modelElementChanged != value)
            {
                _modelElementChanged = value;
                NotifyPropertyChanged();
            }
        }
        get
        {
            retu _modelElementChanged;
        }
    }

    protected override void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
    {
        ModelElementChanged = true;
        base.NotifyPropertyChanged(propertyName);
    }

}