The first idiom allows the caller to specify the type explicitly, whereas the second one will infer it from context. The former is often easier to work with, especially if f() is overloaded further. Recall that in Swift, you can explicitly specify generic arguments on generic types, but not on function calls.
You can also make the two equivalent by using f<T: X>(type: T.Type = T.self) -> T {}. This allows the function to use both inference as well as explicit types. We use that in Alamofire to simplify generic response closures. With explicit types we can use responseDecodable(of: Type.self) { response in } rather than having to make the inference, responseDecodable { (response: AFDataResponse<Type>) in }.
In the case of unsafeBitCast and pointer initialization, it's about requiring that the user be explicit when performing a potentially unsafe operation, rather than relying on type inference.
I'm not as sure about the Codable and UIDropSession usage, but to me it looks like for those the experience of calling those methods is better if you supply the type. Without it you'd need to write e.g. encoder.container() as KeyedEncodingContainer<MyKeyType>.
Personally I believe most of the explicit types in the Codable APIs are a mistake, as the inference should always work, and it was noted in the review. At the least, defaulting them to the inferred type would be nice.