Why is my mesh peeling off when I try to deform it during runtime?

Well, you have to keep track of duplicated vertices and always move them together. So you need the concept of "virtual" or "grouped" vertices. There are several ways how this could be achieved. The most straight forward solution is to just create a List of indices for every "logical" vertex. This of course requires quite a bit of extra memory, though relatively speaking that's not really an issue for most platforms except WebGL which is probably the most restricted platform nowadays when it comes to memory.

Another solution is to create a second array that contains the Lists but initialize that list with null. Only create a List when you have found two or more vertices. You would reference that list from each entry that belongs to that group. That way you can easily look up every connected vertex if there is any. This can also be efficiently implemented with a Dictionary since shared vertices are usually the minority so you don't need that many entries.

Searching for duplicates and grouping them is a quite expensive operation since it's O(n²) in nature as you have to compare every vertex position with every other vertex. For really large meshes this could be optimised with an octree. Though since you usually only need to construct this grouping once at the start it's probably not worth to worry about.

From a usability point of view (depending on what kind of operations you want to do), creating an actual wrapper classs for the mesh and a logical vertex is the neatest way to tackle the issue.

Something like this:

 public class MeshWrapper
 {
     public Mesh mesh;
     public List<Vertex> vertices = new List<Vertex>();
     private List<Vector3> m_Vertices = new List<Vector3>();
     private List<Vector3> m_Normals = new List<Vector3>();
     // implement whatever vertex attributes you also need, UV, tangents, colors, ....
     public List<int> triangles;
 
     public MeshWrapper(Mesh aMesh)
     {
         mesh = aMesh;
         mesh.GetVertices(m_Vertices);
         mesh.GetNormals(m_Normals);
         // ...
         triangles.AddRange(mesh.triangles);
         
         GenerateVertexGroups();
     }
     public void Apply()
     {
         mesh.SetVertices(m_Vertices);
         mesh.SetNormals(m_Normals);
         // ...
         mesh.triangles = triangles.ToArray();
     }
 
     void GenerateVertexGroups(float aMaxPositionError = 0.0001f)
     {
         vertices.Clear();
         float maxErrorSqr = aMaxPositionError * aMaxPositionError;
         for (int i = 0; i < m_Vertices.Count; i++)
         {
             var pos = m_Vertices[i];
             Vertex vertex = null;
             foreach(Vertex v in vertices)
             {
                 float diffSqr = (v.position - pos).sqrMagnitude;
                 if (diffSqr < maxErrorSqr)
                 {
                     vertex = v;
                     break;
                 }
             }
             if (vertex == null)
             {
                 vertex = new Vertex(this);
             }
             vertex.AddVertex(i);
             vertices.Add(vertex);
         }
     }
 
 
     public class Vertex
     {
         private List<int> m_Vertices = new List<int>();
         private MeshWrapper m_Mesh;
         public Vertex(MeshWrapper aMesh)
         {
             m_Mesh = aMesh;
         }
         public void AddVertex(int aVertexIndex)
         {
             if (!m_Vertices.Contains(aVertexIndex))
                 m_Vertices.Add(aVertexIndex);
         }
         public Vector3 position
         {
             get => m_Mesh.m_Vertices[m_Vertices[0]];
             set
             {
                 foreach(int vIndex in m_Vertices)
                     m_Mesh.m_Vertices[vIndex] = value;
             }
         }
         public Vector3 normal
         {
             get => m_Mesh.m_Normals[m_Vertices[0]];
             set
             {
                 foreach (int vIndex in m_Vertices)
                     m_Mesh.m_Normals[vIndex] = value;
             }
         }
         // Add other properties as you need
     }
 }
 

Keep in mind that a Mesh in unity can come in many different flavours. This currently assumes a single submesh and that the mesh is actually a triangle mesh. Unity now supports other topologies as well. Though imported meshes are usually most likely triangle meshes anyways.

I also did not implement all vertex attributes in the Vertex wrapper class. Feel free to add those you may need as well.

With this you can simply create a wrapper around your mesh instance and you get a list of Vertex instances. Those should be grouped already. So if two vertices have the same position (within a tiny error margin) they are actually grouped into the same Vertex instance. When you set one of the vertex properties, it will automatically take care of setting all the grouped vertices to the same value.

Once you're done editing or when you want to update the changes, you just have to call Apply.

Note that this approach doesn't let you add or remove vertices since that would of course break all the housekeeping. This solution is only for editing (transforming) an existing mesh.