Restrict implicit dimensionless ctor to unscaled values

Implicit conversions to/from built-in types appear to be a potential
source of confusion for dimensionless units with a scaling factor (e.g.,
percent<>) [0]. Disallowing implicit conversions in those cases might be
a not-terrible way to eliminate this potential for confusion without
decreasing usability.

The idea for limiting the implicit conversion to unscaled values was
adapted from mpusz/units [1]. I'm not entirely confident this
implementation is the best approach, but it's at least not obviously
broken.

[0]: nholthaus#301

[1]: mpusz/mp-units#412 (comment)

include/units/core.h

@@ -2277,11 +2277,13 @@ namespace units
 
 		/**
 		 * @brief		constructor
-		 * @details		enable implicit conversions from T types ONLY for linear dimensionless units
+		 * @details		enable implicit conversions from T types ONLY for unscaled linear dimensionless units
 		 * @param[in]	value value of the unit
 		 */
 		template<concepts::losslessly_convertible<T> Ty, concepts::dimensionless Cf = ConversionFactor>
-		inline constexpr unit(const Ty value) noexcept : linearized_value(NumericalScale::linearize(static_cast<T>(value)))
+		inline explicit(!std::ratio_equal_v<typename traits::conversion_factor_traits<Cf>::conversion_ratio, std::ratio<1>>) constexpr unit(
+			const Ty value) noexcept
+		  : linearized_value(NumericalScale::linearize(static_cast<T>(value)))
 		{
 		}
 

unitTests/main.cpp

@@ -3055,10 +3055,10 @@ TEST(Consistency, recovers_input_values)
 TEST(Consistency, percent)
 {
 	percent<double> a(50);
-	percent<double> b = 50;
+	// percent<double> b = 50;
 
 	EXPECT_DOUBLE_EQ(a, 50_pct);
-	EXPECT_DOUBLE_EQ(b, 50_pct);
+	// EXPECT_DOUBLE_EQ(b, 50_pct);
 }
 
 TEST_F(UnitType, identity)