primary key constraint updating many-to-many self referential table in entity framework code-first

TL;DR What is the proper way of rehydrating an entity framework object with a self referential many to many relationship from a DTO and updating it with the new values so that the database updates correctly?

I have the following entity (irrelevant stuff trimmed)

 public class Role
    {
        [Key]
        [Required]
        public String RoleId { get; set; }
        public List<Role> Children { get; set; }
    }

In my dbContext, I have set up a many to many relationship

     modelBuilder.Entity<Role>().HasMany(r => r.Children).WithMany();

I'm using MVC front end, with a web-api backend for an n-tier setup, and an mssql database.

The following chain of events happens

Browser->MVC Controller->REST call to Web API->WebAPI Controller->DB Context Query

This chain happens twice, once to view the page in edit mode, and then again when the user pushes the save button to persist.

When setting children on the entity, they always already exist first (IE, you don't create the parent and the children at the same time, you are just adding an existing child to a parent)

There is a DTO used by the MVC model and web API, which I re-hydrate to the entity on the web-api side.

  public IHttpActionResult UpdateRoleInfo(RoleVM roleInfo){
     //lookup existing entity to update
     var existing = db.Roles.FirstOrDefault(y => y.RoleId == roleInfo.ExistingRoleId);

     ...Something happens here (see below for things i've tried)...

    db.SaveChanges();
}

My first try was this :

 existing.Children = roleInfo.Children

This tried to recreate all of the existing children as part of the save. (Primary key constraint violation on the roles table)

I changed that to

  //Fetch all of the roles from the database to lookup the existing children
  var allRoles = GetRoles();
  //Have to reselect the roles from the DB so the DB doesn't try to recreate new ones for the children.
  var childrenToAdd = roleInfo.Roles.Select(role2 => allRoles.FirstOrDefault(r => r.RoleId == role2.RoleId)).ToList();
  existing.Children = childrenToAdd;

This correctly works for updating a role that does not already have any children, to add some the first time, but if you update a role that already has children, it tries to re-add the children to the database a second time, getting a primary key violation on the roles_role table

I then tried pre-pending this code to the second one above,

                existing.Children.Clear();
                db.SaveChanges();

I would expect this to delete all the existing parent-child relationships from the many to many table for this parent, and then recreate them with the new children. Why not?

TL;DR What is the proper way of rehydrating an entity framework object with a self referential many to many relationship from a DTO and updating it with the new values so that the database updates correctly?