doc: fmt ownership.md examples, add okfmt tags

Author: JalonSolov

doc/ownership.md

@@ -6,11 +6,11 @@ with the `-ownership` flag.
 
 ## Quick start
 
-```v
+```v okfmt
 fn main() {
-    s1 := 'hello'.to_owned()
-    s2 := s1          // s1 is moved to s2
-    println(s1)       // error: use of moved value: `s1`
+	s1 := 'hello'.to_owned()
+	s2 := s1 // s1 is moved to s2
+	println(s1) // error: use of moved value: `s1`
 }
 ```
 
@@ -26,158 +26,158 @@ Call `.to_owned()` on a string to create an owned copy. Only strings created wit
 `.to_owned()` participate in ownership tracking — regular string literals and primitive
 types (int, f64, bool, ...) are unaffected.
 
-```v
-s := 'hello'.to_owned()   // s is owned
-t := 'world'               // t is a normal string, no ownership tracking
+```v okfmt
+s := 'hello'.to_owned() // s is owned
+t := 'world' // t is a normal string, no ownership tracking
 ```
 
 ## Move semantics
 
 Assigning an owned value to another variable **moves** it. The original variable
 becomes unusable:
 
-```v
+```v okfmt
 s1 := 'hello'.to_owned()
-s2 := s1          // move
-println(s1)       // error: use of moved value: `s1`
+s2 := s1 // move
+println(s1) // error: use of moved value: `s1`
 ```
 
 Passing an owned value to a function also moves it:
 
-```v
+```v okfmt
 fn takes_ownership(s string) {
-    println(s)
+	println(s)
 }
 
 fn main() {
-    s := 'hello'.to_owned()
-    takes_ownership(s)
-    println(s)    // error: use of moved value: `s`
+	s := 'hello'.to_owned()
+	takes_ownership(s)
+	println(s) // error: use of moved value: `s`
 }
 ```
 
 ### Preventing moves with `.clone()`
 
 Use `.clone()` to make an independent copy instead of moving:
 
-```v
+```v okfmt
 s1 := 'hello'.to_owned()
-s2 := s1.clone()    // s1 is NOT moved
-println(s1)          // ok
-println(s2)          // ok
+s2 := s1.clone() // s1 is NOT moved
+println(s1) // ok
+println(s2) // ok
 ```
 
-```v
-takes_ownership(s.clone())   // s is NOT moved
-println(s)                    // ok
+```v okfmt
+takes_ownership(s.clone()) // s is NOT moved
+println(s) // ok
 ```
 
 ## Borrowing
 
 Pass `&variable` to borrow without moving. The original stays usable:
 
-```v
+```v okfmt
 fn calculate_length(s &string) int {
-    return s.len
+	return s.len
 }
 
 fn main() {
-    s := 'hello'.to_owned()
-    len := calculate_length(&s)
-    println(s)     // ok — s was borrowed, not moved
+	s := 'hello'.to_owned()
+	len := calculate_length(&s)
+	println(s) // ok — s was borrowed, not moved
 }
 ```
 
 Multiple immutable borrows are allowed:
 
-```v
+```v okfmt
 s := 'hello'.to_owned()
 r1 := &s
-r2 := &s    // ok
+r2 := &s // ok
 ```
 
 Mutable borrows via `mut` parameters work too — the variable is usable after the
 call returns:
 
-```v
+```v ignore
 fn append_world(mut s string) {
-    s = s + ' world'
+	s = s + ' world'
 }
 
 fn main() {
-    mut s := 'hello'.to_owned()
-    append_world(mut s)
-    println(s)    // ok — prints "hello world"
+	mut s := 'hello'.to_owned()
+	append_world(mut s)
+	println(s) // ok — prints "hello world"
 }
 ```
 
 ### Borrow restrictions
 
 A borrowed variable cannot be moved or reassigned while the borrow is active:
 
-```v
+```v okfmt
 s := 'hello'.to_owned()
 r := &s
-s2 := s       // error: cannot move `s` because it is borrowed
+s2 := s // error: cannot move `s` because it is borrowed
 ```
 
-```v
+```v okfmt
 mut s := 'hello'.to_owned()
 r := &s
-s = 'world'.to_owned()   // error: cannot assign to `s` because it is borrowed
+s = 'world'.to_owned() // error: cannot assign to `s` because it is borrowed
 ```
 
 ## Return value ownership
 
 Functions that create and return owned values transfer ownership to the caller:
 
-```v
+```v okfmt
 fn gives_ownership() string {
-    return 'hello'.to_owned()
+	return 'hello'.to_owned()
 }
 
 fn main() {
-    s1 := gives_ownership()   // s1 is owned
-    s2 := s1                   // move
-    println(s1)                // error: use of moved value
+	s1 := gives_ownership() // s1 is owned
+	s2 := s1 // move
+	println(s1) // error: use of moved value
 }
 ```
 
 Functions that return a parameter pass ownership through:
 
-```v
+```v okfmt
 fn takes_and_gives_back(s string) string {
-    return s
+	return s
 }
 
 fn main() {
-    s1 := 'hello'.to_owned()
-    s2 := takes_and_gives_back(s1)   // s1 moved in, ownership comes back as s2
-    println(s1)                       // error: s1 was moved
-    println(s2)                       // ok
+	s1 := 'hello'.to_owned()
+	s2 := takes_and_gives_back(s1) // s1 moved in, ownership comes back as s2
+	println(s1) // error: s1 was moved
+	println(s2) // ok
 }
 ```
 
 ## Full example
 
 From the Rust book, translated to V:
 
-```v
+```v okfmt
 fn gives_ownership() string {
-    s := 'hello'.to_owned()
-    return s
+	s := 'hello'.to_owned()
+	return s
 }
 
 fn takes_and_gives_back(a_string string) string {
-    return a_string
+	return a_string
 }
 
 fn main() {
-    s1 := gives_ownership()
-    s2 := 'hello'.to_owned()
-    s3 := takes_and_gives_back(s2)
-    println(s1)   // ok
-    println(s3)   // ok
+	s1 := gives_ownership()
+	s2 := 'hello'.to_owned()
+	s3 := takes_and_gives_back(s2)
+	println(s1) // ok
+	println(s3) // ok
 }
 ```