Formatting text: a number bound by def needs no type

A number bound by def is read as the number written there would be, so
the guide no longer asks for (: n int), and says when (: n double) is
needed.

🤖 Generated with [ECA](https://eca.dev) (anthropic/claude-opus-5-5)

Co-Authored-By: eca-agent <git@eca.dev>

_02_.Writing-programs.sz

@@ -627,7 +627,6 @@ So one thing needs no brackets, and several things are a vec:
 
 @codeblock[#:lang "bjolang"]|{
 (def name "Ada")
-(: n int)
 (def n 3)
 
 (show "Hello\n")                                        ;; Hello
@@ -658,7 +657,7 @@ Anything else is converted first:
 
 @code{BStr}, @code{BInt}, @code{BChar} and @code{BMany} are the cases of @code{Block}. You rarely write them, but like any constructor they are functions, so @code{(vec-map BStr names)} is a vec of blocks.
 
-@strong{A number bound by @code{def}.} The @code{(: n int)} above is needed. @code{(def n 3)} alone does not say which kind of number @code{n} is, as it could still become a long or a double, so it cannot be read as a block, and the compiler says so at @code{n}. The same holds for @code{(def xs [1 2 3])} and @code{(def total (+ 1 2))}. A number that comes from a typed parameter, a record field or a function such as @code{vec-length} has its type already, and a number written in the vec itself, as in @code{["n = " 3]}, is an int.
+@strong{A number bound by @code{def}.} @code{(def n 3)} does not say which kind of number @code{n} is: it could still become a long or a double. Where a block is wanted, it is read as the number written there would be, so @code{["n = " n]} is what @code{["n = " 3]} is, and @code{n} is an int from then on. A number that is used as a double later, as in @code{(+ n 0.5)}, needs @code{(: n double)} above its @code{def}.
 
 @strong{Where a block is wanted.} A string or a vec is read as a block where the compiler knows that a block is wanted: as an argument, as what a function declared to return a @code{Block} returns, and as the value of a binding whose type is written, such as @code{(: parts Block)}. A @code{def} without a type is what its value is: @code{(def parts ["a" "b"])} is a @code{(Vec string)}, and @code{(show parts)} is refused. Write @code{(: parts Block)} above it.
 
@@ -928,7 +927,6 @@ The messages for the common mistakes, and what to write instead:
 | Block: ... found the number 1.5                                        | @code{(numeric 1.5)}                                |
 | Block: ... found a boolean, or found a bool                            | @code{(if b "yes" "no")}                            |
 | Block: ... found a (Vec string)                                        | @code{(vec-map BStr xs)}, or @code{(: xs Block)} above @code{(def xs ...)} |
-| Block: 'n' is a number, and nothing says yet whether it is an int ...  | @code{(: n int)} above @code{(def n 3)}             |
 | Block: ... found a (Vec (Vec ...)), at a lambda that returns a vec    | @code{(each [...])} around the vec the lambda returns |
 }