Dice Paths on a Grid You place a standard die at the origin of a 2D grid that stretches infinitely in every direction. You place the die such that the 1 is facing upwards, the 2 is facing in the negative y direction, and the 3 is facing in the positive x direction, as shown in the figure below:

You then proceed to execute a series of moves with the die by rotating it 90 degrees in the direction of motion. For example, if you were to first rotate the die in the negative x direction, a 3 would be upwards, the 2 would be facing in the negative y direction, and a 6 would be facing in the positive x direction.
The series of moves +y, +y, +x, +x, -y is shown in the figure below, along with the net of the die for clarification (sometimes the net is called a 'right-handed die').

We then proceed to read off the top face of the die after every move. In this case it would read 2, 6, 4, 1, 2, which we call a dice path. Note we do not include the top face of the die in its initial position, but it is always 1.
If the path of the die is such that it returns to the square it started on at the end of its movement, we call this a dice path that returns to the origin.
Challenge
Given a nonempty dice path as input (in a list or any other reasonable format), print a truthy value if the dice path returns to the origin, and a falsy value otherwise. Note that:

The truthy values and falsy values you output do not have to be consistent, but you can't swap them (eg. output a falsy value for a path that returns to the origin and a truthy value otherwise)
The input will be well formed and represent a valid dice path.
There is no limit to how far the die can stray from the origin.

Test Cases
Path                            -&gt; Output
2,1                             -&gt; true
3,1                             -&gt; true
5,4,1,5                         -&gt; true
2,4,1,2                         -&gt; true
4,2,4,1                         -&gt; true
2,4,6,2,4,6,5,4                 -&gt; true
2,4,5,1,4,5,3,6,5,1             -&gt; true
5,6,2,3,5,4,6,3,1,5,6,2         -&gt; true
2,4,1,3,5,1,3,5,6,3,5,6,4,5,6,2 -&gt; true
2                               -&gt; false
4,5                             -&gt; false
5,1,2                           -&gt; false
5,6,2,1                         -&gt; false
5,4,6,5,4,6                     -&gt; false
5,6,4,1,5,4,2,6,5,4             -&gt; false
5,1,2,1,5,6,5,1,2,6,4           -&gt; false
4,6,3,1,5,6,2,1,3,6,4,1         -&gt; false

Scoring
Shortest code in bytes wins.
JavaScript (ES6),  142 ... 122  121 bytes
Expects an array of characters, e.g. ['5','1','2']. Returns 0 or 1.
a=&gt;a.map(n=&gt;D=D.map((_,i)=&gt;D['504405076067'[d*6+i&gt;&gt;1]^i],p+=[w=a.length,-w,1,-1][d=D.indexOf(n)]),p=0,D=[...'254316'])|!p

Try it online!
How?
The array D[] holds the face values in the following order:
 index |    0   |    1   |    2   |    3   |    4   |    5
-------+--------+--------+--------+--------+--------+--------
 face  |  front | behind |  left  |  right |   top  | bottom

We start with D = ['2','5','4','3','1','6'], which is the initial orientation of the die as described in the challenge, using this encoding.
The direction d of the next move is the 0-indexed position of the new top face in D[]:
 index (d) |   0   |   1   |   2   |   3
-----------+-------+-------+-------+-------
 direction |  up   |  down | right |  left

When moving towards direction d, the i-th face in the updated die is the face at the following position in the previous die:
   i = | 0 | 1 | 2 | 3 | 4 | 5
-------+---+---+---+---+---+---
 d = 0 | 5 | 4 | 2 | 3 | 0 | 1
 d = 1 | 4 | 5 | 2 | 3 | 1 | 0
 d = 2 | 0 | 1 | 5 | 4 | 2 | 3
 d = 3 | 0 | 1 | 4 | 5 | 3 | 2

This table is encoded with the following expression:
'504405076067'[d * 6 + i &gt;&gt; 1] ^ i

Try it online!
At each iteration, we update D[] and the position p. We add \$\pm 1\$ to \$p\$ when moving horizontally, or \$\pm w\$ when moving vertically, where \$w\$ is the length of the input array (an upper bound of the distance that can be traveled in a single direction). We test whether we're back to our starting point at the end of the process.