Need Help on Obj Movement via Mouse (particular physics rulles)

Greetings,

I'm working on a 2D Unity puzzle game in which user can drag blocks horizontally with the mouse and place them in correct positions one by one to solve the puzzles in each level. Therefore, I have some fixed-size blocks, each with a

1- Rigidbody2D (for Gravity stuff in case there is empty space that needs to be filled with another block)

2- BoxCollider2D (for the sake of Rigidbody2D , and collision stuff)

3- RayCast2D (to detect distance with other blocks and limit right-side and left-side movements)

4- Single C# script that controls the movement, collision detection and ...

For the dragging part, user clicks on a block (MouseDown) and starts dragging (OnMouseDrag). When released (MouseUp), the block Snaps To Grid ( I've attached a GIF file that illustrates both the movement, and the issue which I need help on)

For the movement part, a block's movement should be limited to available free area on the right and left side. It means that if a block is surrounded by 2 blocks on its right and left side, it shouldn't pass them at all. To do that, I use the Raycast2D functionality that helps me detect collision and limit the movement. Here is the C# script so far :

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.UI;
 
 public class blockProcess : MonoBehaviour
 {

     public Canvas cnv;

     [SerializeField] 
     private Vector3 gridsize = default;
     [SerializeField]
     Transform castPoint_right;
     [SerializeField]
     Transform castPoint_left;
     [SerializeField]
     Transform castPoint_BottomLeft;
     [SerializeField]
     Transform castPoint_Bottomright;
 
 
     float current_mouse_pos;
     bool is_mouse_to_right = false;
     float current_obj_pos;
     float next_obj_pos;
     bool ismovingRight;
 
     bool isClicked = false;
     Vector2 lastAllowedPos;
 
     public float speed;
     private float mZCoord;
     private Vector3 mOffset;
 
 
     void Start()
     {
 
         gridsize = new Vector3(cnv.scaleFactor, 1, 1);
 
     }
 
     string sideCheck_right_collided()
     {
     
         float laserLength = 0.2f;
       
         Vector2 endPos = castPoint_right.position + Vector3.right * laserLength ;
 
         RaycastHit2D hit = Physics2D.Linecast(castPoint_right.position, endPos,  1 << LayerMask.NameToLayer("Default"));
 
         if (hit.collider !=null)
         {
            return hit.collider.tag;
         }
         else
         {
             return "";
         }
     }
   
     string sideCheck_left_collided()
     {
 
    
         float laserLength = 0.2f;
         bool val = false;
         Vector2 endPos = castPoint_left.position + Vector3.left * laserLength;
 
         RaycastHit2D hit = Physics2D.Linecast(castPoint_left.position, endPos, 1 << LayerMask.NameToLayer("Default"));
 
         if (hit.collider != null)
         {
             return hit.collider.tag;
         }
         else
         {
             return "";
         }
 
     }
 
     bool is_mouse_moving_to_right ()
     {
         if (GetMouseAsWorldPoint().x < current_mouse_pos)
         {
             return false;
         }
         else
         {
             return true;
         }
 
     }
 
 
     bool is_obj_moving_to_right ()
     {
         if (next_obj_pos > current_obj_pos)
         {
             return true;
 
         }
         else
         {
             return false;
 
 
         }
     }
 
     private Vector3 GetMouseAsWorldPoint()
 
     {
   
         Vector3 mousePoint = Input.mousePosition;
 
         mousePoint.z = mZCoord;
 
         return Camera.main.ScreenToWorldPoint(mousePoint);
 
     }
 
 
     void OnMouseDrag()
 
     {
        
      
         next_obj_pos = transform.position.x;
 
 
         if (sideCheck_right_collided()=="" && sideCheck_left_collided() == "")
 
           
         {
 
             lastAllowedPos.x = 0;
 
             Vector3 ss = new Vector3(GetMouseAsWorldPoint().x, transform.position.y, GetMouseAsWorldPoint().z);
 
 
             transform.position = Vector3.MoveTowards(transform.position, ss, speed * Time.deltaTime);
 
 
 
         } else
         {
 
 
             lastAllowedPos = new Vector2(transform.position.x, transform.position.y);
 
 
             if (sideCheck_right_collided()!="" && sideCheck_left_collided() == "") {
 
 
                 if (GetMouseAsWorldPoint().x < lastAllowedPos.x && lastAllowedPos.x >0)
             {
 
            
                     Vector3 ss = new Vector3(GetMouseAsWorldPoint().x, transform.position.y, GetMouseAsWorldPoint().z);
                     transform.position = Vector3.MoveTowards(transform.position, ss, speed * Time.deltaTime);
             
            
             }
             }
 
             if (sideCheck_right_collided() == "" && sideCheck_left_collided() != "")
             
                 {
 
   
                 if (GetMouseAsWorldPoint().x > lastAllowedPos.x && lastAllowedPos.x > 0)
                 {
 
 
                     Vector3 ss = new Vector3(GetMouseAsWorldPoint().x, transform.position.y, GetMouseAsWorldPoint().z);
                     transform.position = Vector3.MoveTowards(transform.position, ss, speed * Time.deltaTime);
 
                 }
             }
         }
 }
 }
 }

     private void OnMouseDown()
     {
         isClicked = true;
        
 
         current_obj_pos = transform.position.x;
 
         current_mouse_pos = GetMouseAsWorldPoint().x;
 
         Rigidbody2D rd2 = GetComponent<Rigidbody2D>();
         rd2.gravityScale=0;
 
 
         mZCoord = Camera.main.WorldToScreenPoint(
         gameObject.transform.position).z;
         mOffset = gameObject.transform.position - GetMouseAsWorldPoint();
    
 
     }
 
     private void OnMouseUp()
     {
         isClicked = false;
    
         current_mouse_pos = 0;
 
         Rigidbody2D rd2 = GetComponent<Rigidbody2D>();
         rd2.gravityScale = 1;
 
         SnaptoGrid();
 
     }
 
     private void SnaptoGrid()
     {
        
         var position = new Vector3(Mathf.Round(this.transform.position.x / this.gridsize.x) * this.gridsize.x,
        transform.position.y,
        transform.position.z) ;
 
         this.transform.position = position  ;
     }
 }
 

The issue: As you can see in the GIF attached, If user drags the block normally (with normal reasonable speed), it works like a charm. BUT, when he drags it fast, blocks overlap each other visually and if the dragging is much faster, the Snap To Grid functionality places the moving block in wrong position (pushing another blocking block to the above position and place the moving block under it). I tired testing with different mouse dragging speeds (like 100,35,50 and ...); the less the value, the better the result, but still not Perfect!. I can't decrease the speed as much as I want, because with values less than 50, it affects dragging quality (block moves slower that the mouse).

What would be your approach to solve the issue? any fix to my code ?

Thanks for your attention.

P.S The CastPoints (Red dots) on the bottom of the blocks are for checking collision with specific area of the ground (These are other rules of the game that do not related to the issue in this thread, so no need to mention more)