Unloading unused textures in Unity

I have swapped some of my Sprite objects in favour of Meshes without textures as they should take up less memory.

However, when checking my Profiler, even after the swap the used texture memory is all the same.

So I decided to unload those textures forcefully but things aren't going very well. My intention with this code is to find all the textures by the name of the GameObject they were on (as I just dragged the sprites on the scene via inspector, their name matches. I know which GO-s to look for as only they contain a MeshFilter) and then unload them by hand.

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
 using UnityEngine;
 
 public class DumpUnused : MonoBehaviour
 {
     private TextureContainer swappedTextures = new TextureContainer();
     private IEnumerator Start()
     {
         RemoveSwappedTextures();
         var unloader = Resources.UnloadUnusedAssets();
         while (!unloader.isDone)
         {
             yield return null;
         }
     }
     private void RemoveSwappedTextures()
     {
         //getting all my scene objects that has a mesh filter.
         /*
          * NOTE: I swapped my sprites for generated meshes. 
          * However, the texture memory used didn't decrease so I bet they are still loaded.
          * The textures I used as sprites had the same name as the assets themselves as assets were 
          * just dragged on the scene.
          */
         var sceneObjects =
            UnityEngine.Object.FindObjectsOfType<GameObject>()
             .Where(g => g.GetComponent<MeshFilter>() != null);
         //we have the repaced gameobjects.
 
         //now to get the used textures by their names:
         foreach (var item in sceneObjects)
         {
             //getting everything, even assets
             var strToFind = GetOriginalName(item.name);
              swappedTextures.Append(
              Resources.FindObjectsOfTypeAll<Texture2D>()
              .Where(t => t.name.Equals(strToFind)
              ));
         }
         foreach (var text2Unload in swappedTextures)
         {
             //destroy the loaded textures.
             DestroyImmediate(text2Unload);
         }
         swappedTextures = null;
     }
 
     private string GetOriginalName(string name)
     {
         /*
          * getting the original asset name by the "unity populated name".
          * reason: say I have a "backGr" named texture. 
          * if I copy paste it all over the place, unity makes their name
          * "backGr (1)", "backGr (2)" and so on.
          * So I search until the first whitespace and anything before that
          * is the original name of the texture.
          */
 
         string str = "";
         char c;int i = 0;
         for (c = name[i]; i < name.Length && c != ' '; i++)
         {
             str += c;
         }
         return str;
     }
 
     public class TextureContainer : List<Texture2D>
     {
         //made only for convenience
         public void Append(IEnumerable<Texture2D> textures)
         {
             foreach (var _t in textures)
             {
                 this.Add(_t);
             }
         }
     }
 }

The reason I guess it doesn't do what I want is because the used texture memory is all the same and used total memory is even higher than it was before.

So, unless it is normal for Unity to use more texture memory when there's less textures in the scene, I guess I messed up somewhere.

The question is, how to make this work? If I'm on the wrong road, what are the best practices to Unload textures by name?