doc: Fix grammar, typos, and formatting issues across documentation (JuliaLang#58932)

Co-authored-by: Claude <noreply@anthropic.com>

Author: KristofferC

doc/src/base/base.md

@@ -3,7 +3,7 @@
 ## Introduction
 
 Julia Base contains a range of functions and macros appropriate for performing
-scientific and numerical computing, but is also as broad as those of many general purpose programming
+scientific and numerical computing, but is also as broad as those of many general-purpose programming
 languages. Additional functionality is available from a growing collection of
 [available packages](https://julialang.org/packages/).
 Functions are grouped by topic below.

doc/src/base/collections.md

@@ -275,7 +275,7 @@ Partially implemented by:
 
   * [`Array`](@ref)
 
-## Dequeues
+## Deques
 
 ```@docs
 Base.push!

doc/src/base/numbers.md

@@ -148,7 +148,7 @@ Base.@uint128_str
 
 ## [BigFloats and BigInts](@id BigFloats-and-BigInts)
 
-The [`BigFloat`](@ref) and [`BigInt`](@ref) types implements
+The [`BigFloat`](@ref) and [`BigInt`](@ref) types implement
 arbitrary-precision floating point and integer arithmetic, respectively. For
 [`BigFloat`](@ref) the [GNU MPFR library](https://www.mpfr.org/) is used,
 and for [`BigInt`](@ref) the [GNU Multiple Precision Arithmetic Library (GMP)]

doc/src/base/parallel.md

@@ -159,5 +159,5 @@ non-atomic assignment of `ev.task`)
 In this example, `notify(ev::OneWayEvent)` is allowed to call `schedule(ev.task)` if and
 only if *it* modifies the state from `OWE_WAITING` to `OWE_NOTIFYING`. This lets us know that
 the task executing `wait(ev::OneWayEvent)` is now in the `ok` branch and that there cannot be
-other tasks that tries to `schedule(ev.task)` since their
+other tasks that try to `schedule(ev.task)` since their
 `@atomicreplace(ev.state, state => OWE_NOTIFYING)` will fail.

doc/src/base/reflection.md

@@ -142,7 +142,7 @@ For more information see [`@code_lowered`](@ref), [`@code_typed`](@ref), [`@code
 ### Printing of debug information
 
 The aforementioned functions and macros take the keyword argument `debuginfo` that controls the level
-debug information printed.
+of debug information printed.
 
 ```jldoctest; setup = :(using InteractiveUtils), filter = r"int.jl:\d+"
 julia> InteractiveUtils.@code_typed debuginfo=:source +(1,1)

doc/src/base/scopedvalues.md

@@ -25,7 +25,7 @@ provided scoped value taking priority over previous definitions.
 
 Let's first look at an example of **lexical** scope. A `let` statement begins
 a new lexical scope within which the outer definition of `x` is shadowed by
-it's inner definition.
+its inner definition.
 
 ```jldoctest
 julia> x = 1

doc/src/devdocs/ast.md

@@ -163,7 +163,7 @@ parses as:
 ```
 (if a (block (line 2) b)
     (elseif (block (line 3) c) (block (line 4) d)
-            (block (line 6 e))))
+            (block (line 6) e)))
 ```
 
 A `while` loop parses as `(while condition body)`.

doc/src/devdocs/backtraces.md

@@ -128,4 +128,4 @@ Note that this is only works on Linux. The blog post on [Time Travelling Bug Rep
 A few terms have been used as shorthand in this guide:
 
   * `<julia_root>` refers to the root directory of the Julia source tree; e.g. it should contain folders
-    such as `base`, `deps`, `src`, `test`, etc.....
+    such as `base`, `deps`, `src`, `test`, etc.

doc/src/devdocs/builtins.md

@@ -33,7 +33,9 @@ Core.memoryrefsetonce!
 
 ## Module bindings
 
+```@docs
 Core.get_binding_type
+```
 
 ## Other
 

doc/src/devdocs/callconv.md

@@ -18,10 +18,10 @@ signature.
   * LLVM scalars and vectors are passed by value.
   * LLVM aggregates (arrays and structs) are passed by reference.
 
-A small return values is returned as LLVM return values. A large return values is returned via
+A small return value is returned as LLVM return values. A large return value is returned via
 the "structure return" (`sret`) convention, where the caller provides a pointer to a return slot.
 
-An argument or return values that is a homogeneous tuple is sometimes represented as an LLVM vector
+An argument or return value that is a homogeneous tuple is sometimes represented as an LLVM vector
 instead of an LLVM array.
 
 ## JL Call Convention