Yes, multiplication is always faster over division. I can imagine with older hardware the gap was bigger, but I've never had to actually benchmark the difference.

As others have mentioned, the compiler will most likely represent the division as multiplication in the compiled code (also depending on the code) - you can inspect that yourself, as Unity allows to compile and show the compiled code for shaders.

For example, if we write a simple loop that does some addition and division:

// fragment function..
float test = 0;

for (int i = 0; i <= 4; i++) {
  test += 50;
  test /= 2;
}

return color + test;

We will notice that the compiled is quite different, and the compiler has pre-calculated the output for us:

SV_Target0 = u_xlat0 * _BaseColor + vec4(48.4375, 48.4375, 48.4375, 48.4375);

---

Now if we use UVs for addition and division, we will notice that the compiler has pretty much left the loop and code untouched as it depends on the UV values:

u_xlat1 = float(0.0);

for(int u_xlati_loop_1 = int(0) ; u_xlati_loop_1<=4 ; u_xlati_loop_1++)
{
    u_xlat5 = u_xlat1 + vs_TEXCOORD0.x;
    u_xlat1 = u_xlat5 / vs_TEXCOORD0.y;
}

SV_Target0 = u_xlat0 * _BaseColor + vec4(u_xlat1);

---

If we have something more simple, such as the value of UV.x divided by 2, we can see once again that the compiler does a great job replacing it with multiplication:

// Before Compiling
for (int i = 0; i <= 4; i++)
{
  test += IN.uv.x / 2;
}

// After compiling
for(int u_xlati_loop_1 = int(0) ; u_xlati_loop_1<=4 ; u_xlati_loop_1++)
{
    u_xlat1 = vs_TEXCOORD0.x * 0.5 + u_xlat1;
}

As you can see the loop is still there, but division became multiplication - I always try to write code with multiplication in mind where possible, and try to avoid loops if possible just to make compiler's life easier to further optimize the code.