[Feature Request] Interfaces and Implementors

Nessuno ha ancora preso questa issue.

The current class system is alright, but imagine this: I have a `Stream` class which is extended by `ReadStream`, `WriteStream`, `SeekableStream`, etc.
```lua
---@class Stream
---@field close fun() Deallocates or hangs up a stream.

---@class SeekableStream: Stream
---@field seek fun(whence: SeekWhence, offset: integer): integer

---@class ReadStream: Stream
---@field read fun(self: ReadStream, length: integer): string|nil

---@class WriteStream: Stream
---@field write fun(data: string): integer

---@class StringStream: ReadStream, SeekableStream Streams data out of a string.
```
Now I have a function which takes any Seekable, Readable string. How do I specify this? Either we need a conjunction type (`ReadStream & SeekableStream`, which has keys from both), or we need (preferably) interfaces, which are generic and can be extended by classes. The reason I suggest interfaces is because if I write this:
```lua
---@param length integer
---@return string|nil
function StringStream:read(length)
if self.buffer == nil then
error("Stream is closed", 2)
end
if self.cursor > #self.buffer then
return nil
end
local out = string.sub(self.buffer, self.cursor, math.min(#self.buffer, self.cursor + length))
self.cursor = self.cursor + #out
return out
end
```
and I omit the type annotation, it assumes `read` is already defined because `StringStream` extends `ReadStream`, and it doesn't validate types (arguments and return type are `any`).

Inizia con il comportamento dell’ereditarietà delle classi e delle annotazioni di tipo descritto nell’issue, inclusi gli esempi di Stream, ReadStream, SeekableStream e StringStream. Confronta gli approcci proposti del tipo congiunzione e delle interfacce, quindi verifica che le annotazioni dei metodi ereditati continuino a validare gli argomenti e i tipi restituiti quando le implementazioni omettono le proprie annotazioni.

Scritto dal modello di indicizzazione a partire dal testo della issue.