I believe that {-v[[2]],v[[1]]} is to the left of the velocity vector {v[[1]],v[[2]]}. Note that it also has the same length as the velocity, so to get an offset to the position, you need to normalize it, negate it, and multiply by the offset from the center of the road. The offset you want to use depends on both how you want your display to look and what the lane structure of the road is. For instance, if we ignore pretty, a road with a shared center lane for left turners would have an offset of zero for the shared lane, and an offset of the lane width for the first direction-dedicated lane, 2 lane widths for the next and so on. A typical road does not have such a shared special purpose lane, so you might want to use 1/2 the lane width for the offset of the leftmost lane in each direction, 3/2 the lane width for the second and so on.

I found this solution:

car.progressPosition = Vector3.MoveTowards(car.progressPosition, car.path[car.index].point + lane, Time.deltaTime * speed);
car.car.transform.position = car.progressPosition+car.car.transform.right*2;

Because my cars are generated random. A to B, B to A, A to D, D to C to B to A. But I found the solution

The question is a little vague, so I will have some fun with this. You can make normals by switching tangents. For example, if the tangent t = {t1, t2} then the normal will be n = {-t2, t1}. With this in mind, we can make a roads generator with left and right using the following function:

makeRoad[ centerPointsList_, width_, id_] := 
 Module[ { numberOfPoints, pairs, tangents, normals, leftBorder, 
   rightBorder, pointLocatorOnRoad, normalLocatorOnRoad},
  numberOfPoints = Length[ centerPointsList ];
  pairs = 
   With[ {p = Partition[ centerPointsList, 2, 1 ]}, 
    Append[ p, Last[ p ] ] ];
  tangents = Normalize[ #[[2]] - #[[1]] ] & /@ pairs;
  normals = {-#[[2]], #[[1]]} & /@ tangents;
  leftBorder = 
   Table[ centerPointsList[[i]] + normals[[i]] * width /2, {i, 1, 
     Length[ normals]}];
  rightBorder = 
   Table[ centerPointsList[[i]] - normals[[i]] * width /2, {i, 1, 
     Length[ normals]}];
  pointLocatorOnRoad  = 
   With[ {localPointMap = 
      Thread[ {Range[ 0, 1, 1/(numberOfPoints - 1) ], 
        centerPointsList} ]},
    Interpolation[ localPointMap, InterpolationOrder -> 1 ] ];
  normalLocatorOnRoad = 
   With[ {localPointMap = 
      Thread[ {Range[ 0, 1, 1/(numberOfPoints - 1) ], normals} ]},
    Interpolation[ localPointMap, InterpolationOrder -> 01 ] ];

  $roadDatabase[id, "road" ] = {Line[ leftBorder ], 
    Line[ rightBorder ], Dashed, Line[ centerPointsList ]};
  $roadDatabase[ id, "locate", s_ ] :=  pointLocatorOnRoad[ s ];
  $roadDatabase[ id, "pointMid", s_ ] := { 
    Disk[ pointLocatorOnRoad[ s ], width / 4 ]};
  $roadDatabase[ id, "pointLeft", s_ ] := { 
    Disk[ pointLocatorOnRoad[ s ] + 
      normalLocatorOnRoad[ s ] * width / 4 , width / 4 ]};
  $roadDatabase[ id, "pointRight", s_ ] := { 
    Disk[ pointLocatorOnRoad[ s ] - 
      normalLocatorOnRoad[ s ] * width / 4 , width / 4 ]};

  Graphics[ $roadDatabase[id, "road" ] ]
  ]

Evaluate above then, let's test it:

makeRoad[ Table[ {i, i^2}, {i, 0, 2, 0.2} ], 0.2, 1 ];
makeRoad[ 
  Table[ {3, 2} + 2 {Cos[\[Theta]], Sin[\[Theta]]}, {\[Theta], 0, 
    2 \[Pi], 2 \[Pi] / 64}  ], 0.2, 2 ];
Manipulate[
 Graphics[ {$roadDatabase[1, "road" ], $roadDatabase[2, "road" ],
   Red, $roadDatabase[ 1, "pointLeft", i ], 
   Blue, $roadDatabase[ 1, "pointRight", 1 - i ],
   Red, $roadDatabase[ 2, "pointLeft", i ], 
   Blue, $roadDatabase[ 2, "pointRight", 1 - i ]} ],
 {{i, 0}, 0, 1} ]

Above can be cleaned up to have $roadDatabase hidden and only accessed through some interface. You can also add other graphic primitives to put on your roads (as many as you want with each road being independent). It would be fun having objects for cars too and so on ... but fun is over. Hope this helps.

Much easier! Use the Cross to get the cross product (distinguishes right from left :) between your vector and the normal to the ground, and this will give you the normal direction you need pointing always right or always left (depending on order used). In 2-D, I used it in my previous reply to get a normal from a tangent. In your case, if v is your direction then {-v[[2]], v[[1]]} is the direction pointing right.