Well, it has wider application than one which requires

In the type itself, where everything else is set. So just as
System.Double defines there to be 52 bits of mantissa, 11 bits of scale
and 1 bit of sign, you could have a fixed binary point type which had
63 bits of mantissa, 1 bit of sign, and a scale which was always (say)
512. Instead of using 11 bits to represent the scale, they'd be extra
precision, at the cost of range. You'd always have the same number of
bits before the binary point (even if some were zero) and the same
number of bits after the binary point (even if some were zero).

Just to make this all a bit more concrete, here's a simple fixed-point
type:

using System;

/// <summary>
/// Fixed point type which always has two decimal places.
/// </summary>
class FixedPoint
{
   int unscaled;
   
   public FixedPoint (int unscaled)
   {
       this.unscaled = unscaled;
   }

   public static FixedPoint operator *(FixedPoint x, FixedPoint y)
   {
       long a = (long)x.unscaled * (long)y.unscaled;
       return new FixedPoint ((int)(a/100));
   }

   public static FixedPoint operator +(FixedPoint x, FixedPoint y)
   {
       return new FixedPoint (x.unscaled+y.unscaled);
   }

   // In real life you'd define other operators here, of course
   
   public override string ToString()
   {
       int abs = Math.Abs(unscaled);
       return String.Format("{0}{1}.{2:d2}",
                            unscaled < 0 ? "-" : "",
                            abs/100,
                            abs%100);
   }
}

class Test
{
   static void Main()
   {
       FixedPoint two = new FixedPoint(200);

       FixedPoint twoPointFive = new FixedPoint(250);
       
       Console.WriteLine (two+twoPointFive);
       Console.WriteLine (two*twoPointFive);
   }
}

Here the scale is fixed at 1/100. In other words, the actual value is
the unscaled value divided by 100. The fact that it's not divided by
something which is specified in the value is what makes this type fixed
point rather than floating point.

But the scale is just as "set" in a System.Double... You were using
that quote to support this quote:

<quote>
I always assumed fixed point meant that you set the scale once and then
all values assigned to that variable will use that scale, and floating
point meant the scale was set each time a value was assigned.
</quote>

The quote from the web page doesn't support that as it doesn't mention
variables at all.

Well, you specify the scale when you create the instance - either
implicitly or explicitly. Exactly the same is true with System.Single
or System.Double, except they don't provide constructors to separate
out the parts like System.Decimal does.