feat: quantities can now be multiplied and divided by units

docs/users_guide/framework_basics/character_of_a_quantity.md

@@ -212,9 +212,9 @@ either:
     The following does not work:
 
     ```cpp
-    Quantity auto q1 = la_vector{1, 2, 3} * (m / s);
-    Quantity auto q2 = isq::velocity(la_vector{1, 2, 3} * (m / s));
-    quantity<isq::velocity[m/s]> q3{la_vector{1, 2, 3} * (m / s)};
+    Quantity auto q1 = la_vector{1, 2, 3} * m / s;
+    Quantity auto q2 = isq::velocity(la_vector{1, 2, 3} * m / s);
+    quantity<isq::velocity[m/s]> q3{la_vector{1, 2, 3} * m / s};
     ```
 
     In all the cases above, the SI unit `m / s` has an associated scalar quantity of `isq::length / isq::time`.

docs/users_guide/framework_basics/quantity_arithmetics.md

@@ -136,7 +136,7 @@ However, suppose we multiply or divide quantities of the same or different types
 number by a quantity. In that case, we most probably will end up in a quantity of yet another type:
 
 ```cpp
-static_assert(120 * km / (2 * h) == 60 * (km / h));
+static_assert(120 * km / (2 * h) == 60 * km / h);
 static_assert(isq::width(2 * m) * isq::length(2 * m) == isq::area(4 * m2));
 static_assert(50 / isq::time(1 * s) == isq::frequency(50 * Hz));
 ```
@@ -283,7 +283,7 @@ every time when we want to ensure that we deal with a non-zero or positive value
 We could implement such checks in the following way:
 
 ```cpp
-if (q1 / q2 != 0 * (m / s))
+if (q1 / q2 != 0 * m / s)
   // ...
 ```
 

docs/users_guide/framework_basics/text_output.md

@@ -291,12 +291,12 @@ in the denominator), or never in which case a parenthesis will be added to enclo
 units.
 
 ```cpp
-std::println("{:%Q %q}", 1 * (m / s));         // 1 m/s
-std::println("{:%Q %q}", 1 * (kg / m / s2));   // 1 kg m⁻¹ s⁻²
-std::println("{:%Q %aq}", 1 * (m / s));        // 1 m/s
-std::println("{:%Q %aq}", 1 * (kg / m / s2));  // 1 kg/(m s²)
-std::println("{:%Q %nq}", 1 * (m / s));        // 1 m s⁻¹
-std::println("{:%Q %nq}", 1 * (kg / m / s2));  // 1 kg m⁻¹ s⁻²
+std::println("{:%Q %q}", 1 * m / s);         // 1 m/s
+std::println("{:%Q %q}", 1 * kg / m / s2);   // 1 kg m⁻¹ s⁻²
+std::println("{:%Q %aq}", 1 * m / s);        // 1 m/s
+std::println("{:%Q %aq}", 1 * kg / m / s2);  // 1 kg/(m s²)
+std::println("{:%Q %nq}", 1 * m / s);        // 1 m s⁻¹
+std::println("{:%Q %nq}", 1 * kg / m / s2);  // 1 kg m⁻¹ s⁻²
 ```
 
 Also, there are a few options to separate the units being multiplied:
@@ -319,6 +319,6 @@ to just use the `·` symbol as a separator.
 The `units-unit-symbol-separator` token allows us to obtain the following outputs:
 
 ```cpp
-std::println("{:%Q %q}", 1 * (kg * m2 / s2));   // 1 kg m²/s²
-std::println("{:%Q %dq}", 1 * (kg * m2 / s2));  // 1 kg⋅m²/s²
+std::println("{:%Q %q}", 1 * kg * m2 / s2);   // 1 kg m²/s²
+std::println("{:%Q %dq}", 1 * kg * m2 / s2);  // 1 kg⋅m²/s²
 ```