docs(wiki): document generic classes in @Generic section (#144)

* docs(wiki): document generic classes in @Generic section

The @Generic section predates v3.17.0 and did not mention that classes
can declare type parameters beyond the index-signature examples. Add:

- a sentence in the intro listing the v3.17.0 additions (generic class
  inheritance with type arguments, generic parameters in @overload,
  inline fun<T> function types in @field/@type)
- an example of a generic class with fields and methods, including
  inheritance from an instantiated generic class, with a note on when
  type parameters are substituted
- an example of the inline fun<T> generic function type

All examples verified against lua-language-server 3.18.2 using --check.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: escape backtick

* update old generic example

* add newline

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: carsakiller <carsakiller@gmail.com>

Author: 3 people

src/content/wiki/annotations.mdx

@@ -647,7 +647,9 @@ local Numbers = {}
 
 ### @generic
 
-Generics allow code to be reused and serve as a sort of "placeholder" for a type. Surrounding the generic in backticks (<code>`</code>) will capture the string value from the argument and infer the named class/type as the generic type. [Generics are still WIP](https://github.com/LuaLS/lua-language-server/issues/1861).
+Generics allow code to be reused and serve as a sort of "placeholder" for a type. Surrounding the generic in backticks (<code>\`</code>) will capture the string value from the argument and infer the named class/type as the generic type. [Generics are still WIP](https://github.com/LuaLS/lua-language-server/issues/1861). 
+
+Since `v3.17.0`, classes can declare type parameters (e.g. `Box<T>`), classes can inherit from an instantiated generic class (e.g. `IntegerBox: Box<integer>`), generic type parameters work in [`@overload`](#overload) annotations, and `fun<T>(...)` inline generic function types are supported in [`@field`](#field) and [`@type`](#type) annotations.
 
 **Syntax**
 
@@ -727,12 +729,58 @@ See [Issue #734](https://github.com/LuaLS/lua-language-server/issues/734#issueco
 ---@type Dictionary<boolean>
 local dict = {}
 
--- no warning despite assigning a string
+-- Warning: assigning string to boolean
 dict["foo"] = "bar?"
 
 dict["correct"] = true
 ```
 
+</Accordion>
+<Accordion>
+<span slot="summary">Generic Class with Fields and Methods</span>
+
+```lua
+---@class Box<T>
+---@field value T
+---@field get fun(self: Box<T>): T
+
+---@type Box<integer>
+local box
+
+-- `v` is an integer here
+local v = box.value
+
+-- `got` is an integer here
+local got = box:get()
+
+---A class can also inherit from an instantiated generic class (v3.17.0+)
+---@class IntegerBox: Box<integer>
+
+---@type IntegerBox
+local ibox
+
+-- `v2` and `got2` are integers here as well
+local v2 = ibox.value
+local got2 = ibox:get()
+```
+
+Note: for the type parameter to be substituted through inheritance, members must be declared as `---@field` entries in the class annotation block. A method declared separately (e.g. `---@return T` above `function Box:m() end`) only has `T` substituted when the receiver's type is the instantiated generic class itself (e.g. a value of type `Box<integer>`), not when the method is reached through an inheriting class like `IntegerBox`.
+
+</Accordion>
+<Accordion>
+<span slot="summary">Inline Generic Function Type (v3.17.0+)</span>
+
+```lua
+---@class Utils
+---@field identity fun<T>(value: T): T
+
+---@type Utils
+local utils
+
+-- `s` is a string here
+local s = utils.identity("hello")
+```
+
 </Accordion>
 
 ### @meta