Would this string work as string? Write a program that takes a single line string that you can assume will only contain the characters /\_‾. (That's forward and backward slash, underline and overline. You can use ~ in place of overline if you need since overline is not convenient ASCII.)

For example, one possible input is:

__/‾‾\/\_/‾


Your program needs to output a truthy or falsy value depending on whether the left edge of the string is "connected", so to speak, to the right edge of the string via the lines of the characters. So, if the kerning was a bit less, there would be a solid black (albeit kinky) line all the way from the left edge to the right, like an unbroken piece of string or twine.

The output for the above example would be true because the edges are connected:



To be clear on the connections:


/ connects on its bottom left and top right
\ connects on its top left and bottom right
_ connects on its bottom left and bottom right
‾ (or ~) connects on its top left and top right


Also:


It doesn't matter whether the edges of the string started on the top or the bottom, it only matters that they connect horizontally through the whole length of the string.
You can assume the input string is non-empty, and of course just one line.


Here are some more examples followed by 1 (truthy) if they are connected or 0 (falsy) if not:

__/‾‾\/\_/‾
1

_
1

\
1

/
1

‾
1

___
1

\/
1

/\/
1

/\/\
1

‾‾‾
1

\\
0

‾‾
1

_‾
0

‾_
0

\_____/
1

\/\\/\\___
0

\/\__/‾‾\
1

______/\_____
1

‾‾‾‾‾‾\\_____
0

‾‾‾‾‾‾\______
1

_____/‾‾‾‾‾
1

\___/‾‾‾\___/‾‾‾
1

\_/_\_
0

\_/\_
1

/\/\/\/\/\/\/\/\/\/\/\/
1

____________________
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾/
0

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
1

/\‾/\‾___/\_\/__\/\‾‾
0


The shortest code is the winner.
Jelly, 9 bytes
-1 byte thanks to @EriktheOutgolfer
Expect ~ instead of ‾. Returns \$0\$ or \$1\$.
O*Ɲ:⁽8ƇḂẠ

Try it online!, Truthy test suite, Falsy test suite
Using this formula (but otherwise similar to the 11-byte version below):
$$n=\left\lfloor\frac{x^y}{15145}\right\rfloor$$
The transition is valid if \$n\$ is odd, or invalid if \$n\$ is even.
Commented
O*Ɲ:⁽8ƇḂẠ     - main link, taking a string          e.g. &quot;\_/&quot;
O             - get ASCII codes                     --&gt;  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         --&gt;  [92**95, 95**47]
   :⁽8Ƈ       - integer division by 15145           --&gt;  [23964828…8421, 59257069…0485]
       Ḃ      - least significant bit (i.e. parity) --&gt;  [1, 1]
        Ạ     - all values equal to 1?              --&gt;  1


Jelly,  14 12  11 bytes
Supports (and expects) the ‾ character in the input string. Returns \$0\$ or \$1\$.
O*Ɲ%276%7ỊẠ

Try it online!, Truthy test suite, Falsy test suite
How?
Given two consecutive characters of ASCII codes \$x\$ and \$y\$, we want a function that checks whether they form a valid transition.
We need a non-commutative operation, because the result may change when the characters are reversed. For instance, _/ is valid but /_ is not.
Using exponentiation, a possible formula1 is:
$$n=(x^y \bmod 276)\bmod 7$$
The transition is valid if \$n\le1\$, or invalid if \$n&gt;1\$.
 chars |    x |    y | (x**y)%276 | %7 | valid
-------+------+------+------------+----+-------
   __  |   95 |   95 |      71    |  1 |  yes
   _/  |   95 |   47 |     119    |  0 |  yes
   _‾  |   95 | 8254 |     265    |  6 |   no
   _\  |   95 |   92 |     265    |  6 |   no
   /_  |   47 |   95 |      47    |  5 |   no
   //  |   47 |   47 |      47    |  5 |   no
   /‾  |   47 | 8254 |       1    |  1 |  yes
   /\  |   47 |   92 |       1    |  1 |  yes
   ‾_  | 8254 |   95 |     136    |  3 |   no
   ‾/  | 8254 |   47 |      88    |  4 |   no
   ‾‾  | 8254 | 8254 |     196    |  0 |  yes
   ‾\  | 8254 |   92 |     196    |  0 |  yes
   \_  |   92 |   95 |      92    |  1 |  yes
   \/  |   92 |   47 |      92    |  1 |  yes
   \‾  |   92 | 8254 |     184    |  2 |   no
   \\  |   92 |   92 |     184    |  2 |   no

1. Found with a brute-force search in Node.js (using BigInts)
Commented
O*Ɲ%276%7ỊẠ   - main link, taking a string          e.g. &quot;\_/&quot;
O             - get ASCII codes                     --&gt;  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         --&gt;  [92**95, 95**47]
   %276       - modulo 276                          --&gt;  [92, 119]
       %7     - modulo 7                            --&gt;  [1, 0]
         Ị    - ≤1?                                 --&gt;  [1, 1]
          Ạ   - all values equal to 1?              --&gt;  1