[Feature Request] Interfaces and Implementors

Personne n'a encore pris cette 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`).

Commencez par le comportement de l’héritage de classes et des annotations de types décrit dans l’issue, notamment les exemples Stream, ReadStream, SeekableStream et StringStream. Comparez les approches proposées du type de conjonction et des interfaces, puis vérifiez que les annotations des méthodes héritées valident toujours les arguments et les types de retour lorsque les implémentations n’ont pas leurs propres annotations.

Rédigé par le modèle d'indexation à partir du texte de l'issue.