Why is casting float to double applicable?
This is really not a computer science question...

First, you failed to distinguish between "casting" and "conversion". In many computer languages, "casting" is an explicit instruction to convert a value from some type to another type. For example in C, 

double d = 3.7;
float f = d; // Automatic conversion, no casting

double d = 3.7;
float f = (float) d; // Casting as requested by programmer
double e = (float) d; // Casting to float, followed by conversion to double


So what you were really talking about was value conversion, not casting. (Being precise in what you write is arguably part of computer science). 

The effect of any conversion is defined by the computer language in question. "Shrinking down (leveraging) the significant bits" is something that doesn't make any sense at all. Bits don't have a size, you can't shrink them. And the word "leveraging" doesn't mean what you think it means. I assume you meant "removing the significant bits". 

But that's not how value conversion is defined. In C and C++, it is defined in terms of values. A conversion between scalar types results in the exact same value if the old value can be represented in the new type. If the value cannot be represented, then there are rules for conversions between integer types; in some cases the value is modified according to rules in the language, sometimes the value is modified according to implementation defined rules (and "implementation defined" has a very specific meaning in C and C++ that you need to learn), or it is undefined behaviour. 

Converting non-integral floating point values to integer values first rounds the value towards zero, and then other rules apply. Conversion between floating-point values will produce the original value if possible, rounds according to rounding rules in the language if that is not possible, with additional rules if the value is too large to represent. 

Do you notice how nothing at all here is talking about bits? 

Swift distinguishes between conversions that cannot fail and conversion that can fail. Conversions that can fail produce an optional value. Which is a totally different thing. For example, you cannot convert UInt to Int, only to an optional Int. You cannot convert Int64 to Int32, only to an optional Int32. But you can convert Int32 to Int64, because it is a conversion that cannot fail.