doc: more xrefs for conversion manual (#31127)

doc/src/manual/conversion-and-promotion.md

@@ -47,7 +47,7 @@ without the programmer asking for it explicitly.
 One example is assigning a value into an array: if `A` is a `Vector{Float64}`, the expression
 `A[1] = 2` should work by automatically converting the `2` from `Int` to `Float64`, and
 storing the result in the array.
-This is done via the `convert` function.
+This is done via the [`convert`](@ref) function.
 
 The `convert` function generally takes two arguments: the first is a type object and the second is
 a value to convert to that type. The returned value is the value converted to an instance of given type.
@@ -95,7 +95,7 @@ ERROR: MethodError: Cannot `convert` an object of type String to an object of ty
 Some languages consider parsing strings as numbers or formatting numbers as strings to be conversions
 (many dynamic languages will even perform conversion for you automatically), however Julia does
 not: even though some strings can be parsed as numbers, most strings are not valid representations
-of numbers, and only a very limited subset of them are. Therefore in Julia the dedicated `parse`
+of numbers, and only a very limited subset of them are. Therefore in Julia the dedicated [`parse`](@ref)
 function must be used to perform this operation, making it more explicit.
 
 ### When is `convert` called?
@@ -104,10 +104,10 @@ The following language constructs call `convert`:
 
   * Assigning to an array converts to the array's element type.
   * Assigning to a field of an object converts to the declared type of the field.
-  * Constructing an object with `new` converts to the object's declared field types.
+  * Constructing an object with [`new`](@ref) converts to the object's declared field types.
   * Assigning to a variable with a declared type (e.g. `local x::T`) converts to that type.
   * A function with a declared return type converts its return value to that type.
-  * Passing a value to `ccall` converts it to the corresponding argument type.
+  * Passing a value to [`ccall`](@ref) converts it to the corresponding argument type.
 
 ### Conversion vs. Construction
 
@@ -208,7 +208,7 @@ do with the type hierarchy, and everything to do with converting between alterna
 For instance, although every [`Int32`](@ref) value can also be represented as a [`Float64`](@ref) value,
 `Int32` is not a subtype of `Float64`.
 
-Promotion to a common "greater" type is performed in Julia by the `promote` function, which takes
+Promotion to a common "greater" type is performed in Julia by the [`promote`](@ref) function, which takes
 any number of arguments, and returns a tuple of the same number of values, converted to a common
 type, or throws an exception if promotion is not possible. The most common use case for promotion
 is to convert numeric arguments to a common type:
@@ -286,7 +286,7 @@ can be convenient to do promotion automatically.
 
 Although one could, in principle, define methods for the `promote` function directly, this would
 require many redundant definitions for all possible permutations of argument types. Instead, the
-behavior of `promote` is defined in terms of an auxiliary function called `promote_rule`, which
+behavior of `promote` is defined in terms of an auxiliary function called [`promote_rule`](@ref), which
 one can provide methods for. The `promote_rule` function takes a pair of type objects and returns
 another type object, such that instances of the argument types will be promoted to the returned
 type. Thus, by defining the rule:
@@ -310,7 +310,7 @@ one does not need to define both `promote_rule(::Type{A}, ::Type{B})` and
 `promote_rule(::Type{B}, ::Type{A})` -- the symmetry is implied by the way `promote_rule`
 is used in the promotion process.
 
-The `promote_rule` function is used as a building block to define a second function called `promote_type`,
+The `promote_rule` function is used as a building block to define a second function called [`promote_type`](@ref),
 which, given any number of type objects, returns the common type to which those values, as arguments
 to `promote` should be promoted. Thus, if one wants to know, in absence of actual values, what
 type a collection of values of certain types would promote to, one can use `promote_type`: